java之13天 字符串 (一)

字符串

/**
 * String 类适用描述字符串事物
 * 那么他提供了多个方法对字符串进行操作
 * 
 * 常见的操作有那些呢?
 * "abc"
 * 
 * 1.获取 
 *   1.1  字符串中的包含的字符数,也就是字符串的长度
 *      int length() :获取 长度
 *   1.2 根据位置获取位置上的某个字符
 *      char charAt(int index);
 *   1.3 根据字符 获取字符在 字符串中第一次出现的位置
 *      int indexOf(int ch);  //接受的 ASCII码
 *      int indexOf(int ch,int fromIndex);//从fromIndex指定位置开始,获取ch 在字符串中出现的位置
 *      
 *      int indexOf(String str); 返回的是str在字符串中第一初相的位置
 *      int indexOf(String ch,int fromIndex);//从fromIndex指定位置开始,获取ch 在字符串中出现的位置
 *      int lastIndexOf(String ch,int fromIndex);//从fromIndex指定位置开始,获取ch 在字符串中出现的位置
 *      int codePointAt(int index) 返回指定索引处的字符（Unicode 代码点）。
 *      int codePointBefore(int index) codePointBefore(int index) 
 *      int codePointCount(int beginIndex, int endIndex) 返回此 String 的指定文本范围中的 Unicode 代码点数。
 *      
 * 2.判断
 *    2.1 字符串中是否包含某一子字符串
 *         boolean contains(str);
 *         indexOf(str) 功能都可以实现
 *    2.2 字符串是否有内容
 *         boolean  isEmpty(); 原理就是判断 长度是否为0 
 *    2.3 字符串是否以指定内容开头
 *         boolean startsWith(str)
 *    2.4 字符串是否 以制定内容结尾
 *		   boolean endsWith(str)  
 *    2.5 判断字符内容是否相同  复写了Object类中的equals 方法
 *        boolean equals();
 *    2.6 判断内容是否相同,并忽略大小写.
 *        boolean equalsIgnoreCase(); 
 *        
 * 3.转换
 *    3.1 将字符数组转成字符串
 *        构造函数  String (char[])
 *              String (char[],int offset,count); 将字符数组中的一部分转成字符串
 *        静态方法
 *              static String copyValueOf(char[])
 *              static copyValueOf(char[] data, int offset, int count)
 *              static String valueOf(int);
 *    3.2 将字符串转成字符数组
 *           char[] toCharArray();
 *           
 *         
 *    3.3 将字节数组转成字符串
 *    	    构造函数  String (byte[])
 *              String (byte[],int offset,count); 将字节数组中的一部分转成字符串
 *    3.4 将字符串转成 字节数组
 *           byte[] getBytes();
 *    3.5 将基本类型数据转成字符串
 *        static String valueOf(int);
 *        static Stirng valueOf(double);
 *      
 *     特殊: 字符串和字节数组在转换的过程中,是可以指定编码表的 
 *     
 * 4. 替换
 *    String replace(oldchar,new char);
 *    Stirng replace(oldcharsequence,newcharsequence);
 *    
 * 5.切割
 *    String[] split(regex);
 *
 * 6.子串,获取字符串中的一部分 
 *   String substring(int begin);
 *   String substring(int begin,int end);
 * 7.转换, 去除空格,比较
 *   7.1 将字符串转换成大写或者小写
 *     String toUpperCase()
 *     String toLowercase()
 *   7.2 将字字符串两端的多个空格去掉
 *   	String  trim()
 *   7.3 对字符串进行自然顺序的比较
 *      int compareTo   this< param  <0  this=param =0 this> param >0
 *
 *   
 */
public class StringDemo {
	
	public static void method_7(){
		String s="    Hello   java     ";
		sop(s.toUpperCase());
		sop(s.toLowerCase());
		sop(s.trim());
	}
	
	
	public static void method_subString(){
		String s="hellojava";
		sop(s.substring(2));  //从指定位置开始到结尾,如果角标不存在,会出现字符串角标越界异常
		sop(s.substring(2,4));// 包含头,不包含尾
	}
	public static void method_split(){
		String s="zhangs,lisi,wangwu";
		String[] names=s.split(",");
		
		for (String string : names) {
			sop(string);
		}
	}
	public static void method_replace(){
		String s="hello java";
		String s1=s.replace('q', 'n');  //如果替换的字符串在原字符串中不存在 ,则返回的还是原字符串
		sop(s);
		sop(s1);
		String s2=s.replace("java", "word");
		sop(s2);
	}
	
	public static void method_trans(){
		char[] arr={'a','b','c','d','e','f','g'};
		String s=new String(arr);
		sop("s="+s);
		s=new String(arr,1,3);   // 1.是角标  3 是个数 
		sop("s="+s);
		
		sop(String.copyValueOf(arr));
		sop(String.copyValueOf(arr,1,3));
		/*sop(str);
		sop(str);
		sop(str);
		sop(str);
		sop(str);*/
		
	}
	
	public static void method_is(){
		String str="ArrayDemo.java";
		sop(str.startsWith("Array"));
		sop(str.endsWith(".java"));
		sop(str.contains("Demo"));
		
	}
	public static void method_get(){
		String str="abcdeakpf";
		//长度
		sop(str.length());
		//根据索引获取字符
		sop(str.charAt(4));   //当访问到字符从中不存在的角标的时候 会发生,StringIndexOfBoundsException.
		
		//根据字符获取索引
		sop(str.indexOf('m',3));//当找不到 制定的字符的时候 返回-1
		
		//反向索引一个字符出现的位置
		sop(str.lastIndexOf('a'));  //脚本还是从左边开始 标识,  只是从右边开始查找 
		
		//返回制定脚本上的ASCII码　
		sop(str.codePointAt(3));  // c 的ASCII 
		//返回指定索引之前的字符的 SCAII嘛
		sop(str.codePointBefore(3));  // b 的ASCII
		//指定文本范围中的 Unicode 代码点数。
		sop(str.codePointCount(0,6));
		
		
	}
	
	public static void sop(Object obj){
		System.out.println(obj);
		
	}
	
	public static void main(String[] args) {
		String s1="abc";// s1是一个类类型的变量,"abc"是一个对象   "abc" 存在 常量池中 
		  //字符串最大的特点,是一旦被初始化就不可以被改变
		s1="kk";
		System.out.println(s1);  //只是 s1的指向 改变了  abc 这个对象 还是没有改变
		
		String s2=new String("abc"); //new String()  "abc"
		String s3="abc";  //由于常量池中有 abc  所以 不会再开辟空间来 新建对象
		
		//s1和s2 有什么区别?
		//s1 代表一个对象
		//s2代表 两个对象.
		
		System.out.println(s1=s2); //false
		System.out.println(s1.equals(s2));// true -->String 类复写了Object类中的equals方法
		//该方法用于判断字符串是否相同
		System.out.println(s1==s3);
		
		System.out.println("====================================");
		method_get();
		System.out.println("====================================");
		method_trans();
		System.out.println("====================================");
		method_replace();
		System.out.println("====================================");
		method_subString();
		System.out.println("====================================");
		method_7();
		
	}

}

字符串的练习

/**
 * 字符串的练习
 * 1.模拟一个trim方法.去掉字符串两端的空格.
 *    思路
 *    1)判断字符串第一个位置是否为空格,如果是继续乡下判断,知道不是空格为止
 *       结尾处判断空格也是如此
 *    2)当开始和结束都判断到不是空格时,就是要获取的字符串.
 *    
 * 2.将一个字符串进行反转,将字符串中指定的部分进行反转.
 *   思路
 *    1)曾经学习过对数组的元素进行反转
 *    2)将字符串编程数组,对数组反转
 *    3)将反转后的数组变成字符串
 *    4)只要将反转的部分的开始和结束位置作为参数传递即可  
 * 
 * 3.获取一个字符串在另一个字符串中出现的次数
 *   思路
 *   1)定义个计数器
 *   2)获取kk第一次出现的位置
 *   3)从第一次出现的位置后剩余的字符串中继续获取kk出现的位置
 *     每获取一次计数器加一
 *   4)当获取不到十计数器完成
 * 
 * 4.两个字符串中最大相同子串,第一个动作,将短的那个串进行长度一次递减的子串打印.
 *   "abcwerthelloyuiodef"
 *   "cvhelloohnm"
 *   思路:
 *   1)将短的那个子串安装长度递减的凡是获取到.
 *   2)将每个获取到的子串去长串中判断是否包含.如果包含,已经找到!
 *
 */

public class StringDemo1 {

	public static void sop(String str){
		System.out.println(str);
	}
	public static void main(String[] args) {
		String s="     Hello  world     ";
		
		String str="kkabkkcdHellokkefghkks";
		sop(myTrim(s));
		sop(reversString(s,7,13));
		sop(reversString(s));
		sop("count="+getSubCount(str,"kk"));
		sop("count====="+getSubCount2(str,"kk"));
		
		sop(getMaxSubString(str,"ssdHellokefghk"));
	}
	//练习四
	public static String getMaxSubString(String s1,String s2){
		String max="",min="";
		max=s1.length()>s2.length()? s1:s2;
		min=max==s1?s2:s1;
		
		for(int x=0;x<min.length();x++){
			for(int y=0,z=min.length()-x;z!=min.length()+1;y++,z++){
				String temp=min.substring(y,z);
				if(max.contains(temp))  //s1.indexOf(temp)!=-1 return temp
					return temp;
			}
		}
		return "";
	}
	
	
	//练习三,方三
	public static int getSubCount3(String str,String key){
		int count=0,index=0;
		while((index=str.indexOf(key,index))!=-1){
			count++;
			index=index+key.length();
		}
		return count;
	}
	
	public static int getSubCount2(String str,String key){
		//不建议 使用这个 因为如果开头为 key 的话 就会出现有时候多一个情况
		return str.split("kk").length; 
	}
	
	//练习三,获取一个字符串在另一个字符串中出现的次数
	public static int getSubCount(String str,String key){
		int count=0;
		int index=0;
		while((index=str.indexOf(key))!=-1){
			count++;
			str=str.substring(index+key.length());
		}
		return count;
	}
	
	
	
	//练习二 ,将字符串反转
	public static String reversString(String s,int start,int end){
		//字符串编程数组
		char[] chs=s.toCharArray();
		
		//反转数组
		revers(chs,start,end);
		
		//将数组编程字符串
		return new String(chs);
	}
	
	public static String reversString(String s){
		return reversString(s,0,s.length());
	}
	private static void revers(char[] arr,int x,int y){
		for(int start=x,end=y-1;start<end;start++,end--){
			swap(arr,start,end);
		}
	}
	
	private static void swap(char[] arr,int start,int end){
		char temp=arr[start];
		arr[start]=arr[end];
		arr[end]=temp;
	}
	
	
	
	//练习一,取出字符串两端空格.
	public static String myTrim(String str){
		int start=0,end=str.length()-1;
		while(start<=end && str.charAt(start)==' ')
			start++;
		while(start<=end && str.charAt(end)==' ')
			end--;
		return str.substring(start,end+1);
	}

}