string 獲取 判斷 轉換 替換 切割 子串 轉換

String

特點

1：String是一個對象

2：String是一個常量，不可以被改變

3：String s1 = "abc" ;  和 String s2 = new String ("abc");的區別！

4：String判斷 equals的判斷，是判斷字符串是否相同。

字符串最大的特點：一旦被初始化，就不可以被改變。

class  Test
{
	public static void main(String[] args) 
	{
		String s1 = "abc" ;  //S1是一個類類型變量，“abc”是一個對象
				　//字符串最大的特點：一旦被初始化，就不可以被改變。
		
		s1 = "kk";	//這個不是改變abc的對象內容；而是改變了s1指向的地址。

		System.out.println(s1);  //輸出結果是kk
	}
}

String s1 = "abc" ;  
String s2 = new String ("abc");

s1和s2的區別
s1在內存中有一個對象，“abc”
s2在內存中有兩個對象，分別是 new 和 “abc”。

s1.equals(s2)

String類複寫了Object類中的equals方法。該方法用於判斷字符串是否相同。

class  Test
{
	public static void main(String[] args) 
	{
		String s1 = "abc" ;  
		String s2 = new String ("abc");
		String s3 = "abc";

		System.out.println(s1==s2);		//輸出結果爲false，因爲是s2有兩個對象；
		System.out.println(s1.equals(s2));	//輸出結果爲true，因爲地址值相同；
							//String類複寫了Object類中的equals方法，該方法用於判斷字符串是否相同。
		System.out.println(s1==s3);	/*輸出結果爲true，當創建完s1的對象“abc”後，
						s3創建時，因爲內從中已經有了abc，就不會再單獨創建。*/<pre name="code" class="java"><span style="font-family: Arial, Helvetica, sans-serif;">                                                                                            /*s1和s2的區別s1在內存總有一個對象，“abc”s2在內存中有兩個對象，　</span><pre name="code" class="java">　                                           <span style="font-family: Arial, Helvetica, sans-serif;">　分別是 new 和 “abc”。equals 判斷字符串，判斷的是字符串內容是否相同。*/　
      　}　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　
}</span>

String類是用於描述字符串事物。

提供了多個方法對字符串進行操作。

常見操作有：

1.獲取

1.1 字符串中包含的字符數，也就是字符串的長度。

int length()； 獲取長度。

1.2獲取指定腳標上的字符。

char charAt（int index）；

1.3獲取該字符（字符串）位置的腳標。

int indexOf（int ch）； 返回的是ch在字符串中第一次出現的位置。

int indexOf (int ch, int fromIndex) 從fromIndex指定位置開始獲取，ch在字符串中出現的位置。

int indexOf（String str）； 返回的是str在字符串中第一次出現的位置。

int indexOf (String str , int fromIndex) 從fromIndex指定位置開始獲取，str在字符串中出現的位置。

int lastIndexOf（int ch）； 反向索引ch在字符串中第一次出現的位置。

int lastIndexOf (int ch, int fromIndex) 反向索引，從fromIndex指定位置開始獲取，ch在字符串中出現的位置

class  Test
{
	public static void method_get()
	{
		String str = "abcdefghav" ;

		sop(str.length());		//長度
		sop(str.charAt(4));		//根據索引獲取字符
		sop(str.indexOf('b'));	　　　　//根據字符獲取索引
		sop(str.indexOf('a',2));	//指定起始位置，根據字符獲取索引
		sop(str.indexOf('z',2));	//如果沒有找到，返回-1.
		sop(str.lastIndexOf('d'))	//反響索引
	}
	
	public static void sop(Object obj)
	{
		System.out.println(obj);	
	}

	public static void main(String[] args) 
	{	
		method_get();
	}
}

2 判斷

2.1 字符串中是否包含某一個子串

boolean contains（str）；

特殊之處：indexOf（str）；可以索引str第一次出現的位置，如果返回-1.表示str中不存在與字符串中。

所以，也可以用於對指定判斷是否包含。

if(str.contains("aa")!=-1); 就是包含。

而且該方法既可以判斷，又可以獲取出現的位置。

2.2字符串中是否有內容

boolean isEmpty（）；原理就是判斷長度是否爲0.

2.3字符串 是否是以指定內容開頭

boolean startsWith（str）；

2.4字符串是否是以指定內容結尾

boolean endsWith（str）；

2.5判斷字符串內容是否相同，複寫了Object類中的equals方法。

boolean equals（str）；

2.6判斷內容是否相同，忽略大小寫。

boolean equalsIngoreCase（）；

class  Test
{
	public static void method_is()
	{
		String str = "ArrayDemo.java";

		sop(str.startsWith("Array"));	//判斷文件名稱是否已Array開頭
		sop(str.endsWith(".java"));	//判斷文件類型是否是.java
		sop(str.contains("Demo"));	//判斷文件中是否包含Demo
		sop(str.isEmpty());			//判斷字符串長度是否爲零
	}

	public static void sop(Object obj)
	{
		System.out.println(obj);	
	}

	public static void main(String[] args) 
	{	
		method_is();
	}
}

3 轉換

3.1將字符數組轉換成字符串

構造函數：String(char[])

String(char[],offset,count)；將字符數組中的一部分轉換成字符串

靜態方法：static String copyValueOf(char[]); 

 static String copyValueOf(char[] data, int offset ,int count)

static String valueOf(char[])；

3.2將字符串轉成字符數組 *****

char[]  toCharArray()；

3.3將字節數組轉成字符串

String(byte[])

String(byte[],offset,count)；將字節數組中的一部分轉換成字符串

3.4將字符串轉成字節數組

byte[] getByte（）；

3.5將基本數據類型轉換成字符串。

static String valueOf（int）；

static String valueOf（double）；

特殊注意：字符串和字節數組在轉換過程中，是可以指定編碼表的。

class  Test
{
	public static void method_trans()
	{
		char[] arr = {'a','b','c','d','e','f'};
		byte[] by = {'a','b','c','d','e','f'};
		String str = "abcdefg";
		
		String s = new String(arr);		//構造函數，打印函數
		sop("s="+s);
			
		String s1 = new String(arr,2,3);  //構造函數,將字符數組中的一部分轉換成字符串
		sop("s1="+s1);
		
		String s3 = new String(by,2,3);	//將字節數組轉成字符串
		sop("s3"+s3);
		
		char[] c = str.toCharArray();	//將字符串轉成字符數組
		for (int x=0;x<c.length ;x++ )
		{
			sop("char c=["+c[x]+"]");
		}
		
		byte[] c1 =str.getBytes();	//將字符串轉成字節數組
		for (int x=0;x<c1.length ;x++ )
		{
			sop("char c1=["+c1[x]+"]");
		}
				
	}
	
	public static void sop(Object obj)
	{
		System.out.println(obj);	
	}

	public static void main(String[] args) 
	{	
		method_trans();
	}
}

4 替換

String replace (oldchar,newchar);

class  Test
{
	public static void method_replace()
	{
		String r = "hello java";
		sop("r="+r);	//輸出：r=hello java
		
		String r1 = r.replace("a","e");	//替換字符
		sop("r1="+r1);	//輸出：r1=hello jeve，在新字符串上改變。	
		sop("r="+r);	//輸出：r=hello java，因爲字符串不變特性
		
		String r2 = r.replace("d","e");	//如果要替換的字符不存在，返回的還是遠串
		sop("r2="+r2);

		String r3 = r.replace("java","doc"); //替換多個字符
		sop("r3="+r3);	//輸出：r1=hello doc，在新字符串上改變。	
		sop("r="+r);	//輸出：r=hello java，因爲字符串不變特性
	}
	
	public static void sop(Object obj)
	{
		System.out.println(obj);	
	}

	public static void main(String[] args) 
	{	
		method_replace();
	}
}

5 切割

String[]  split(regex);

class  Test
{
	public static void method_split()
	{
		String s = "zhangsan,lisi,wangwu";

		String[] arr = s.split(",");	//切割
		for(int x=0 ;x<arr.length; x++)
		{
			sop(arr[x]);	/*輸出結果
								zhangsan
								lisi
								wangwu	
							*/
		}
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);	
	}

	public static void main(String[] args) 
	{	
		method_split();
	}
}

6子串，獲取字符串中的一部分

String substring (begin)；

String substring (begin,end);

class  Test
{
	public static void method_sub()
	{
		String s = "abcdefg";
		sop(s.substring(3));	//從指定位置開始到結尾
		sop(s.substring(3,5));	//包含頭，不包含尾
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);	
	}

	public static void main(String[] args) 
	{	
		method_sub();
	}
}

7轉換 ，去除空格，比較

7.1將字符串轉成大寫，或者小寫

String toUpperCase();

String toLowerCase() ;

7.2將字符串兩端的多個空格去除

String trim();

7.3對兩個字符串進行自然順序的比較

int  compareTo(string);

 

class  Test
{
	public static void method_case()
	{
		String s = "  Hello Java   ";
		
		sop(s.toUpperCase());	//全大寫
		sop(s.toLowerCase());	//全小寫

		sop(s.trim());			//去除空格
	
		String s1= "xyz";
		String s2= "bcdf";
		sop(s1.compareTo(s2)); //比較兩個字符串 轉int後的大小
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);	
	}

	public static void main(String[] args) 
	{	
		method_case();
	}
}

練習

/*	
1.模擬一個trim方法，去除字符串兩端的空格。
	思路
	1 判斷字符串第一個位置是否是空格，如果是繼續向下判斷，直接到不是空格爲止。
		結尾處判斷空格也是如此。
	2 當開始和結束都判斷到不是空格時，就是要獲取的字符串。
*/

class  Test
{	
	public static String myTrim(String str)
	{
		int start =0 ;
		int end =str.length()-1;

		while (start<=end && str.charAt(start)==' ')
			start++;

		while (start<=end && str.charAt(end)==' ')
			end--;

		return str.substring(start,end+1);
	}
	

	public static void main(String[] args) 
	{	
		String str = "  abc c   ";
		sop(myTrim(str));
	}

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

/*	
2將一個字符串進行反轉，將字符串中指定部分進行反轉，“abcdefg”-abfedcg
思路
1，將字符串變成數組，。
2，對數組反轉
3，將數組變成字符串。
*/
class  Test
{	
	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 reverse(char[] arr)
	{
		for(int start=0,end=arr.length-1;start<=end;start++,end--)
			swap(arr,start,end);
	}
	private static void swap(char[] arr,int start,int end)
	{
		char s = arr[start];
		arr[start]=arr[end];
		arr[end]=s;
	}
	public static void main(String[] args) 
	{	
		String str = "abcdefg";
		sop(str);
		sop(reverseString(str));		//調換整個字符串
		sop(reverseString(str,2,6))；	//調換指定字符
	}

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

/*	
3獲取一個字符串，在另一個字符串中出現的次數。
“abkkcdkkefkkskk”
思路
1，定義個計算器，
2，獲取kk第一次出現的位置。
3，從第一次出現位置後，從剩餘的字符串中繼續獲取kk出現的位置。
	每獲取一次就計數一次。
4，當獲取不到時，計算完成。
*/

class  Test
{	
	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 = "abkkcdkkefkkskk";
		sop("count="+getSubCount_2(str,"kk"));

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

/*
4,獲取兩個字符串中最大相同子串，第一個動作：將短的那個串進行長度依次遞減的子串打印
"abcwerthelloyuiodef"
"chvhellobnm"
思路：
1，將短的那個子串按照長度遞減的方式獲取到。
2，將沒獲取到的子串去長串中判斷是否包含
		如果包含，已經找到
*/
class  Test
{	
	public static String getMaxSubring(String s1,String s2)
	{
		String max="",min="";
		max=(s1.length()>s2.length())?s1:s2;
		min=(max==s1)?s2:s1;
		sop("max="+max);
		sop("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);
				
				if(max.contains(temp))	//或者 if(max.indexOf(temp)!=-1)
					return temp;
				
			}
		}
		return "";
	}
	
	public static void main(String[] args) 
	{	
		String s1 = "abcwerthelloyuiodef";
		String s2 = "chvhellobnm";
		sop(getMaxSubring(s1,s2));
	}

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