黑馬程式員--String、StringBuffer、StringBuilder、基本資料類型對象包裝類（Java）

------Java教育訓練、Android教育訓練、iOS教育訓練、.Net教育訓練、期待與您交流！ -------

一.String

1.概述：

java中用String類進行描述。對字元串進行了對象的封裝。這樣的好處是可以對字元串這種常見資料進行友善的操作。對象封裝後，可以定義N多屬性和行為。

String是字元串的類類型，用于描述字元串事物。

2.特點：

一旦被初始化就不可以被改變。存放在方法區中的常量池中。

3.面試題：

String s1 = "abc";

String s2 = new String("abc");

String s3 = "abc";

s1和s2有什麼差別？

s1在記憶體中有一個對象abc。

s2在記憶體中有兩個對象abc、new。

s1==s2 ( false )

s1.equals(s2) ( true )

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

s1==s3 ( true )

因為“abc”這個字元串對象已經在記憶體中存在，作為字元串這種特殊的對象，這種在常量池中存在的資料。s3進行初始化時，發現abc已經在記憶體中存在，就不會再獨立開辟空間，因為再開辟空間就比較浪費空間。是以為了節約記憶體，在字元串對象當中隻要字元串相同，那麼s1和s3就指向同一個對象。

4.操作字元串方法：

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（);反向索引。

2）、判斷：

2.1 字元串中是否包含某一個子串：boolean contains(str);

特殊之處：indexOf（str）可以索引str第一次出現的位置，如果傳回-1表示該str不在字元串中存在。是以，也可以用于對指定判斷是否包含。

2.2 字元串中是否有内容（長度是否為0）：boolean isEmpty();

2.3 字元串是否以指定内容開頭：boolean startsWith(str);

2.4 字元串是否以指定内容結尾：boolean endsWith(str);

2.5 判斷字元串内容是否相同：boolean equals(str);

2.6 判斷内容是否相同，并忽略大小寫：boolean equalsIgnoreCase();

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);将位元組數組中的一部分轉成字元串。count表示個數。

3.4 将字元串轉成位元組數組：

byte[] getBytes();

3.5 将基本資料類型轉成字元串：

StringvalueOf(int);

StringvalueOf(double);

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

4）、替換：

String replace(oldchar,newchar);

5）、切割：

String[] split(regex);

6）、子串。擷取字元串中的一部分。

String substring(begin);

String substring(begin,end);注：包含頭，不包含尾。

7）、轉換，去除空格，比較。

7.1 将字元串轉成大寫或小寫：

String toUpperCase();

String toLowerCase();

7.2 将字元串兩端的多個空格去除：

String trim();

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

int compareTo(string);

注：如果參數字元串等于此字元串，則傳回值0；如果此字元串按字典順序小于字元串參數，則傳回一個小于0的值；如果此字元串按字典順序大于字元串參數，則傳回一個大于0的值。

這7中字元串操作方法代碼展現：

（代碼 StringMethodDemo.java）：

class StringMethodDemo 
{
	public static void main(String[] args) 
	{
		method_get();//擷取
		method_is();//判斷
		method_trans();//轉換
		method_replace();//替換
		method_split();//切割
		method_sub();//擷取子串
		method_7();
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void method_get()//擷取
	{
		String str = "abcdec";
        sop(str.length());//長度
		sop(str.charAt(3));//根據索引擷取字元
		sop(str.indexOf('c',3));//根據字元擷取索引
		sop(str.lastIndexOf('b'));//反向索引
	}
	public static void method_is()//判斷
	{
		String str = "StringMethodDemo.java";
		sop(str.startsWith("String"));//判斷檔案名稱是否是String單詞開頭。
		sop(str.endsWith(".java"));//判斷檔案名稱是否是.java的檔案。
		sop(str.contains("Demo"));//判斷檔案中是否包含Demo。
	}
	public static void method_trans()//轉換
	{
		char[] arr = {'a','b','c','d','e'};
		String s = new String(arr);//将字元數組轉成字元串。
		String s1 = new String(arr,1,3);//注意：1是從角标1開始，3是個數。
		sop("s= "+s);
		sop("s1= "+s1);
		//将字元數組轉成字元串。
		String str = "asdfg";
		char[] chs= str.toCharArray();
		for(int x=0;x<chs.length;x++)
			sop("ch="+chs[x]);       
	}
	public static void method_replace()//替換
	{
		String s = "hello java";
		String s1 = s.replace('a','n');
		sop("s="+s);
		sop("s1="+s1);
	}
	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]);
	}
	public static void method_sub()//擷取子串
	{
		String s = "abcdef";
		sop(s.substring(2));//從指定位置到結尾。
		sop(s.substring(2,4));//包含頭，不包含尾。
	}
	public static void method_7()
	{
		String s = "   Hello Java   ";
		sop(s.toUpperCase());//大寫
		sop(s.toLowerCase());//小寫
		sop(s.trim());//将字元串兩端的多個空格去除。

		String s1 = "acc";
		String s2 = "aaa";
		sop(s1.compareTo(s2));//對兩個字元串進行自然順序的比較。
	}

}

5.字元串操作練習：

（代碼 StringTest.java）：

//練習1：将一個字元串進行反轉。
	/*
	思路：
	1，将字元串變成數組。
	2，将數組反轉。
	3，将數組變成字元串。
	*/
class StringTest 
{
	public static void main(String[] args) 
	{
		String s = "abcd";
		System.out.println(s);
		System.out.println(reverseString(s));
	}

	public static String reverseString(String str)
	{
		char[] chs = str.toCharArray();
		reverse(chs);
		return new String(chs);
	}
	//反轉指定字元數組位置
	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 x,int y)
	{
		char temp = arr[x];
		arr[x] = arr[y];
		arr[y] = temp;
	}
}

（代碼 StringTest2.java）：

//練習2：擷取一個字元串在另一個字元串中出現的次數。

class StringTest2 
{
	public static void main(String[] args) 
	{
		String str = "asddfgddhhjkdd";
		System.out.println(getSubCount(str,"dd"));
	}
	public static int getSubCount(String str,String key)
	{
		int count = 0;
		int index = 0;
		while((index=str.indexOf(key))!=-1)
		{
			System.out.println(str);
			str = str.substring(index+key.length());
			count++;
		}
		return count;
	}
}

（代碼 StringTest3.java）：

//擷取兩個字元串中的最大相同子串。
/*
思路：
1、将短的一個字元串與長的進行比較，
如果沒有，則将短串的字串按長度遞減的方式擷取。
2、将每次擷取的子串，去長串中判斷是否包含，包含即找到。
*/
class StringTest3 
{
	public static void main(String[] args) 
	{
		String s1="asdfhellosfg";  
        String s2="frhelloy";  
        System.out.println(getMaxSubstring(s1,s2)); 
	}
	public static String getMaxSubstring(String s1,String s2)  
    {  
        String max,min;  
        max=(s1.length()>s2.length())?s1:s2; 
        min=(s1.length()<s2.length())?s1:s2;
  
        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))//如果長串包含，則表示找到  
                    return temp;
            }  
        }  
        return "沒有相同的字元串";
    }  
  
}

二.StringBuffer

1.概述：

字元串緩沖區，可以對字元串進行增删改查操作，StringBuffer是一個容器。

2.特點：

1）、長度可變。

2）、可以位元組操作多個資料類型。

3）、最終會通過toString方法變成字元串。

3.與數組差別：

1）、StringBuffer長度是可變化的。（數組是固定的）。

2）、StringBuffer可以直接操作多個資料類型。（數組隻能操作一個）。

4.容器中的方法：

1）、添加。

StringBuffer append(data):在緩沖區中添加資料。添加到尾部。

StringBuffer insert(index,data):在指定位置插入資料。

2）、删除。

StringBuffer delete(start,end);删除從start至end-1範圍的元素（包含頭，不包含尾）。

StringBuffer deleteCharAt(index);删除指定位置的元素。

注意：例子：sb.delete(0,sb.length());清空緩沖區（包含頭，不包含尾）。

3）、擷取（查找）。

int indexOf(string); 傳回指定子字元串在此字元串中第一次出現處的索引。沒有就傳回-1。

int indexOf(string,int fromIndex);從指定位置開始查找字元串。

int lastIndexOf(string); 傳回指定子字元串在此字元串中最右邊出現處的索引。

int lastIndexOf(string,int fromIndex); 從指定的索引開始反向搜尋。

string substring(start); 傳回start到結尾的子串。

string substring(start,end); 傳回start至end-1的子串。

4）、修改。

StringBuffer replace(start,end,string);将start至end-1替換成string。（包含頭，不包含尾）。

void setCharAt(index,char);替換指定位置的字元。

void setLength(len);将原字元串置為指定長度的字元串。

5）、反轉。

StringBuffer reverse();字元串反轉，如果String想反轉就要轉換成StringBuffer再反轉。

6）、将緩沖區中指定資料存儲到指定字元數組中。

void getChars(int srcBegin, int srcEnd,char[] dst,int dstBegin)

三.StringBuilder

1.JDK1.5 版本之後出現了StringBuilder。

2.StringBuffer與StringBuilder差別：

1）、StringBuffer是線程同步。(安全)

2）、StringBuilder是線程不同步。（不安全）

以後開發，建議使用StringBuilder。提高效率。如果遇到多線程，使用StringBuffer或自己加鎖。

3.更新三因素：

1）、提高效率。

2）、簡化書寫。

3）、提高安全性。

四.基本資料類型對象包裝類

1.概念：是按照面向對象思想将基本資料類型封裝成了對象。

2.好處：

1）、可以通過對象中的屬性和行為操作基本資料。

2）、可以實作基本資料類型和字元串之間的轉換。

3.基本資料類型對象包裝類：

byte Byte

short Short

int Integer

long Long

boolean Boolean

float Float

double Double

char Character

4.基本資料類型轉成字元串：

基本資料類型+" "

基本資料類型.toString(基本資料類型值)；

例如：Integer.toString(34);//将34整數變成"34"。

5.字元串轉成基本資料類型：

xxx a=Xxx.parseXxx(string);

例如：

int a = Integer.parseInt("123");靜态。注意：必須傳入數字格式的字元串。

boolean b = Boolean.parseBoolean("true");

Integer i = new Integer("123");

int num = i.intValue();//跟上面的靜态方式的結果一樣，但這種屬于對象調用方式。

6.十進制轉成其他進制。

轉成二進制：toBinaryString

轉成八進制：toOctalString

轉成十六進制：toHexString

7.其他進制轉成十進制。

parseInt(String,radix);

例如：

int x = Integer.parseInt("110",10);

int a = Integer.parseInt("3c",16);

8.在jdk1.5版本後，對基本資料類型對象包裝類進行更新。在更新中，使用基本資料類型對象包裝類可以像使用基本資料類型一樣，進行運算。

Integer i = new Integer(4); 1.5版本之前的寫法。

Integer i = 4; 自動裝箱，1.5版本後的寫法。

i = i + 2; i進行自動拆箱。變成了int類型。和2進行加法運算。再将和進行裝箱賦給i。

9.小知識點：

Integer x=128;

Integer y=128;

x==y （false）

Integer m=127;

Integer n=127;

m==n （ true）

在裝箱時，如果數值在byte範圍之内，那麼數值相同，不會産生新的對象，也就是說多個數值相同的引用指向的是同一個對象。

黑馬程式員--String、StringBuffer、StringBuilder、基本資料類型對象包裝類（Java）

一.String

二.StringBuffer

三.StringBuilder

四.基本資料類型對象包裝類

繼續閱讀

Spring Boot整合Security系列步驟及問題排查（一）—— 起步

黑馬程式員-Java基礎-知識點-記錄彙總(end)

java基礎-String常用api

java學習筆記-java泛型

list和set的差別

Maven中log4j和logback配置檔案的書寫

了解java的I/O流：

I/O流與檔案操作一.FILE類二.檔案的遞歸操作三.FileFilter過濾器的原理和使用四.I/O流五.字元輸入輸出流六.Path類（學校老師補充…）七.Files工具類（在nio包下，學校老師講的）八.基于Files的I/O流操作

線程池有這一篇就夠了

Spring - JDK的動态代理

java拾遺之關鍵字final

File類詳解

Java兩個相同對象之間資料整合

一張圖捋清Java發展史一張圖捋清Java發展史

Java靜态字段和靜态方法