黑马程序员_Java基础String类

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[];

    /** Cache the hash code for the string */
    private int hash; // Default to 0
     public String() {
        this.value = new char[0];
    }
     public String(char value[]) {
        this.value = Arrays.copyOf(value, value.length);
    }
| 

    public static void main(String[] args){  
        String s0 = "adanac";  
        String s1 = "adanac";  
        String s2 = "ada" + "nac";  
          
        System.out.println(s0 == s1);       // true  
        System.out.println(s0 == s2);       // true  
    }

    public static void main(String[] args){  
        String s0 = "adanac";  
        String s1 = new String("adanac");  
        String s2 = "ada" + new String("nac");  
          
        System.out.println(s0 == s1);       // false  
        System.out.println(s0 == s2);       // false  
        System.out.println(s1 == s2);       // false  
    }

public class Test {
    public static void main(String srgs[])
    { 

        String str = "hello java!" ; 
  
        String str1 = new String("hello java!") ;

		//str 和 str1 的区别在于：str 内存中有一个对象，而str1 内存中有两个对象。
         
        sop(str.length()) ;
        
        sop(str.charAt(i))  ; 
        sop(str.indexOf(‘a‘)) ;
        sop(str.indexOf(‘a‘,7)) ;

        sop(str.indexOf("java")) ;
        sop(str.lastIndexOf(‘a‘)) ; 
    }
    //打印函数：
    public static void sop(Object obj) 
    {
        System.out.println(obj); 
    }
}

public class Test{
    public static void main(String args[])
    {
        String str1 = "hello java!" ; 
        String str2 = new String("hello java!") ;  
        
        System.out.println(str1.equals(str2));  //true [String类重写了Object类的equals 方法]
        System.out.println(str1 == str2);  //false
    } 
}

public class Test {
    public static void main(String args[])
    {
        char[] ch = {‘h‘,‘e‘ ,‘l‘ ,‘l‘ ,‘o‘ ,‘ ‘ , ‘j‘ , ‘a‘ , ‘v‘ ,‘a‘} ;
	// 构造函数转换：
	// 将字符数组转换成字符串：
        String str1 = new String (ch) ; 
        System.out.println(str1);
		// 从ch[] 下标 6开始，后的4个字符 ，转换成字符串。
        String str2 = new String (ch,6,4) ;
        System.out.println(str2);
        
	//  静态方法：
	//  将字符数组转换成字符串：
        String str3 = String.copyValueOf(ch) ; 
        System.out.println(str3); 
	//  从ch[] 下标 6开始，后的4个字符 ，转换成字符串。
        String str4 = String.copyValueOf(ch,0,5) ;
        System.out.println(str4);
        
        String str = "hello java" ; 
	// 将字符串转换成字符数组；
        char[] ch1 = str.toCharArray() ;
        for(int i = 0 ; i < ch1.length ; i ++)
            System.out.print("‘"+ch1[i] +"‘");
        System.out.println();   
    }
}

String str = "    hello,java,Adanac    " ; 
      
//替换字符
String str1 = str.replace(‘,‘, ‘ ‘) ;
       
//切割
String[] str2 = str.split(",") ; 

// 除去字符串两端的多个空格：
System.out.println(str1.trim()); 

String str2 = "hello world " ; 
//对比两个字符串进行自然顺序的比较
System.out.println(str.compareTo(str2));

class StringTest 
{

	public static void sop(String str)
	{
		System.out.println(str);
	}
	public static void main(String[] args) 
	{
		String s = "      ab cd      ";

		sop("("+s+")");
		s = myTrim(s);
		sop("("+s+")");

		sop("("+reverseString(s)+")");
		
	}


	//练习二：将字符串反转。
	/*
	思路：
	1，将字符串变成数组。
	2，对数组反转。
	3，将数组变成字符串。
	*/

	public static String reverseString(String s,int start,int end)
	{
		//字符串变数组。
		char[] chs = s.toCharArray();

		//反转数组。
		reverse(chs,start,end);

		//将数组变成字符串。
		return new String(chs);
	}
	public static String reverseString(String s)
	{
		return reverseString(s,0,s.length());
		
	}

	private static void reverse(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 x,int y)
	{
		char temp = arr[x];
		arr[x] = arr[y];
		arr[y] = temp;
	}

	//练习一，去除字符串两端空格。
        /*思路：
	1，判断字符串第一个位置是否是空格，如果是继续向下判断，直到不是空格为止。
		结尾处判断空格也是如此。
	2，当开始和结尾都判断到不是空格时，就是要获取的字符串。
        */
	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);
	}
}

class  StringTest
{

	/*
	练习三。
	获取一个字符串在另一个字符串中出现的次数。
		"abkkcdkkefkkskk"

		思路：
		1，定义个计数器。
		2，获取kk第一次出现的位置。
		3，从第一次出现位置后剩余的字符串中继续获取kk出现的位置。
			每获取一次就计数一次。
		4，当获取不到时，计数完成。

		*/
		
	public static int getSubCount(String str,String key)
	{
		int count = 0;
		int index = 0;

		while((index=str.indexOf(key))!=-1)
		{
			sop("str="+str);
			str = str.substring(index+key.length());

			count++;	
		}
		return count;
	}

	/*
	练习三，方式二。

	*/
	public static int getSubCount_2(String str,String key)
	{
		int count = 0;
		int index = 0;

		while((index= str.indexOf(key,index))!=-1)
		{
			sop("index="+index);
			index = index + key.length();
					count++;
		}
		return count;
	}

	public static void main(String[] args) 
	{
		String str = "kkabkkcdkkefkks";
			///sop("count====="+str.split("kk").length);不建议使用。
		sop("count="+getSubCount_2(str,"kk"));
	}

	public static void sop(String str)
	{
		System.out.println(str);
	}
}

 

class  StringTest
{
	/*
	练习四。
	获取两个字符串中最大相同子串。第一个动作：将短的那个串进行长度一次递减的子串打印。
	"abcwerthelloyuiodef"
	"cvhellobnm"
	思路：
		1，将短的那个子串按照长度递减的方式获取到。
		2，将每获取到的子串去长串中判断是否包含，
			如果包含，已经找到！。
	*/
	public static String getMaxSubString(String s1,String s2)
	{

		String max = "",min = "";

		max = (s1.length()>s2.length())?s1: s2;

		min = (max==s1)?s2: s1;
		
		sop("max="+max+"...min="+min);
		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);
				
				sop(temp);
				if(max.contains(temp))//if(s1.indexOf(temp)!=-1)
					return temp;
			}
		}
		return "";
	}


	public static void main(String[] args) 
	{
		String s1 = "ab";
		String s2 = "cvhellobnm";
		sop(getMaxSubString(s2,s1));
	}

	public static void sop(String str)
	{
		System.out.println(str);
	}
}

public class StringBufferDemo 
{
    public static void main(String[] args)
    {  
        System.out.println("");
        DeleteString(new StringBuffer("hello java")) ;
        System.out.println("-------------------------------");
        ReplaceString(new StringBuffer("hello java")) ;
    }
    public static void CreateString(StringBuffer stringBuffer )
    {
	// 添加数据到stringBuffer 结尾处，
        stringBuffer.append("hello").append("java").append(520).append(true) ; 
        System.out.println(stringBuffer);
		
	//在指定位置添加数据。
        stringBuffer.insert(0, "heima,"); 
        System.out.println(stringBuffer);
    }
    public static void DeleteString(StringBuffer stringBuffer)
    { 
	//删除start至end的字符序列。
        stringBuffer.delete(0,6);
        System.out.println(stringBuffer);

	//删除指定位置的字符
        stringBuffer.deleteCharAt(1) ;
        System.out.println(stringBuffer); 
    }
    public static void ReplaceString(StringBuffer stringBuffer)
    {
	//替换指定字符序列。
        stringBuffer.replace(6, stringBuffer.length(), "adanac") ; 
        System.out.println(stringBuffer);
        stringBuffer.setCharAt(5, ‘,‘) ;
        System.out.println(stringBuffer);

	//反转
        stringBuffer.reverse(); 
        System.out.println(stringBuffer); 
    }
}