字元串相關的類:String String類:代表字元串,Java 程式中的所有字元串字面值(如 "abc" )都作 為此類的實例實現。 String是一個final類,代表不可變的字元序列 當字元串重新賦值時,需要重新指定記憶體區域,不能使用原有的value進行賦值 當對現有的字元串進行連接操作時, ...
字元串相關的類:String
String類:代表字元串,Java 程式中的所有字元串字面值(如 "abc" )都作 為此類的實例實現。
- String是一個final類,代表不可變的字元序列
- 當字元串重新賦值時,需要重新指定記憶體區域,不能使用原有的value進行賦值
- 當對現有的字元串進行連接操作時,也需要重新指定記憶體區域賦值,也不能 在原有的value上進行賦值
- 當調用String的replace()方法修改指定字元或字元串時,也需要重新指定記憶體區域進行賦值
- 也就是說對String的任何修改都是重新的造一個
- 字元串是常量,用雙引號引起來表示。它們的值在創建之後不能更改
- String內部定義了final char value[] 用於存儲字元串數據
- String實現了Serializable介面,表示字元串是支持序列化的,實現了 Comparable介面,表示String可以比較大小
- 通過字面量的方式(區別於new)給一個字元串賦值,此時的字元串的值是聲明在字元串常量池中的
- 字元串常量池是不會存儲相同內容的字元串
public void test1(){
String s1 = "abc";//字面量的方式
String s2 = "abc";
System.out.println(s1 == s2);// ture , 比較的是s1和s2的地址值
s1 = "hello";
System.out.println(s1); // hello
System.out.println(s2); // abc
String s3 = "abc";
s3 += "def";
System.out.println(s3); // abcdef
System.out.println(s2 == s3); // false , 此時的s2和s3的地址值已經不同
String s4 = "abc";
String s5 = s4.replace('a' , 'd');
System.out.println(s4); // abc
System.out.println(s5); // dbc
}
1. String的實例化方式
- 通過字面量定義的方式:此時的s1和s2的數據是聲明在方法區的字元串常量池中
- 通過new + 構造器的方式:此時的s3和s4保存的地址,是數據在堆空間中開闢空間以後對應的地址值
public void test2(){
String s1 = "Java";
String s2 = "Java";
String s3 = new String("Java");
String s4 = new String("Java");
System.out.println(s1 == s2); // true
System.out.println(s1 == s3); // false
System.out.println(s1 == s4); // false
System.out.println(s3 == s4); // false
Person p1 = new Person("Tom",18);
Person p2 = new Person("Tom",18);
System.out.println(p1.name.equals(p2.name)); // true , String重寫了equals方法,此時比較的就是內容了
System.out.println(p1.name == p2.name); // true , 兩個對象裡面還是字面量定義的方式賦值
}
註:兩個對象裡面還是字面量定義的方式賦值
面試題
String s = new String("abc")方式創建對象,在記憶體中創建了幾個對象?
兩個,一個是堆空間的new的結構,一個是char[]對應的常量池中的數據 "abc"
2. 字元串的特性
重點:
- 常量與常量的拼接結果在常量池中,且常量池中不會存在相同內容的常量
- 只要其中一個是變數,結果就在堆中
- 如果拼接的結果調用intern()方法,返回值就是在常量池中
public void test3(){
String s1 = "Java";
String s2 = "Python";
String s3 = "JavaPython";
String s4 = "Java" + "Python";
String s5 = s1 + "Python";
String s6 = s1 + s2;
System.out.println(s3 == s4); // true
System.out.println(s3 == s5); // false
System.out.println(s4 == s5); // false
System.out.println(s3 == s6); // false
String s7 = s5.intern();
System.out.println(s7 == s3); //true
}
特別註意:當 final String s1 = “java”,這個也就相當於一個常量了
3. 面試題:
good and best
這裡可以參考之前的Java的值傳遞
若在scr前面加一個this,情況會是怎樣?
package com.atguigui.exer;
/**
* @author MD
* @create 2020-07-12 9:41
*/
public class StringTest {
String str = new String("good");
char[] ch = {'t','e','s','t'};
public void change(String str, char ch[]){
this.str = "test ok";
ch[0] = 'b';
}
public static void main(String[] args) {
StringTest ex = new StringTest();
ex.change(ex.str,ex.ch);
System.out.println(ex.str);
System.out.println(ex.ch);
// test ok
// best
}
}
4. String常用的方法
註意String的不可變性,原字元不變
- int length():返回字元串的長度: return value.length
- char charAt(int index): 返回某索引處的字元return value[index]
- boolean isEmpty():判斷是否是空字元串:return value.length == 0
- String toLowerCase():使用預設語言環境,將 String 中的所有字元轉換為小寫
- String toUpperCase():使用預設語言環境,將 String 中的所有字元轉換為大寫
- String trim():返回字元串的副本,忽略前導空白和尾部空白
- boolean equals(Object obj):比較字元串的內容是否相同
- boolean equalsIgnoreCase(String anotherString):與equals方法類似,忽略大 小寫
- String concat(String str):將指定字元串連接到此字元串的結尾。 等價於用“+”
- int compareTo(String anotherString):比較兩個字元串的大小 涉及到字元串排序
- String substring(int beginIndex):返回一個新的字元串,它是此字元串的從 beginIndex開始截取到最後的一個子字元串。
- String substring(int beginIndex, int endIndex) :返回一個新字元串,它是此字 符串從beginIndex開始截取到endIndex(不包含)的一個子字元串。
- boolean endsWith(String suffix):測試此字元串是否以指定的尾碼結束
- boolean startsWith(String prefix):測試此字元串是否以指定的首碼開始
- boolean startsWith(String prefix, int toffset):測試此字元串從指定索引開始的 子字元串是否以指定首碼開始
- boolean contains(CharSequence s):當且僅當此字元串包含指定的 char 值序列 時,返回 true,也就是字元串A中是否包含字元串B
- int indexOf(String str):返回指定子字元串在此字元串中第一次出現處的索引
- int indexOf(String str, int fromIndex):返回指定子字元串在此字元串中第一次出 現處的索引,從指定的索引開始
- int lastIndexOf(String str):返回指定子字元串在此字元串中最右邊出現處的索引
- int lastIndexOf(String str, int fromIndex):返回指定子字元串在此字元串中最後 一次出現處的索引,從指定的索引開始反向搜索
- 註:indexOf和lastIndexOf方法如果未找到都是返回-1
- String replace(char oldChar, char newChar):返回一個新的字元串,它是 通過用 newChar 替換此字元串中出現的所有 oldChar 得到的。
- String replace(CharSequence target, CharSequence replacement):使 用指定的字面值替換序列替換此字元串所有匹配字面值目標序列的子字元串。
- String replaceAll(String regex, String replacement) : 使用給 定 的 replacement 替換此字元串所有匹配給定的正則表達式的子字元串。
- String replaceFirst(String regex, String replacement) : 使用給 定 的 replacement 替換此字元串匹配給定的正則表達式的第一個子字元串。
- boolean matches(String regex):告知此字元串是否匹配給定的正則表達式
- String[] split(String regex):根據給定正則表達式的匹配拆分此字元串。
- String[] split(String regex, int limit):根據匹配給定的正則表達式來拆分此 字元串,最多不超過limit個,如果超過了,剩下的全部都放到最後一個元素中。
5. String與基本數據類型轉換
String ---> 基本數據類型、包裝類
- 調用包裝類的靜態方法:parseXxx(str)
基本數據類型、包裝類 --- >字元串
- 調用String的valueOf(xxx)
public void test2(){
String str = "123";
int num = Integer.parseInt(str);
String str1 = String.valueOf(num);
}
String ---> char[] : 調用String的toCharArray()
char[] ---> String: 調用String的構造器
public void test3(){
String str = "asdf123";
char[] charArray = str.toCharArray();
for (int i = 0; i < charArray.length; i++) {
System.out.println(charArray[i]);
}
String str1 = new String(charArray);
System.out.println(str1);
}
編碼:String ---> byte[] :調用String的getBytes()
解碼:byte[] ---> String : 調用String的構造器
/**
* 編碼:字元串 -->位元組 (看得懂的---->看不懂的二進位數據)
* 解碼:位元組 ---> 字元串(看不懂的二進位數據---->看得懂的)
* @throws UnsupportedEncodingException
*/
@Test
public void test4() throws UnsupportedEncodingException {
String str = "abc123你好";
byte[] bytes = str.getBytes(); // 使用預設的字元集進行轉換 UTF-8 編碼
System.out.println(Arrays.toString(bytes));
String str1 = "abc123你好";
byte[] bytes1 = str1.getBytes("gbk"); // 指定編碼格式
System.out.println(Arrays.toString(bytes1));
System.out.println("---------------------");
String str2 = new String(bytes); // 解碼,使用的預設的格式
System.out.println(str2);
String str3 = new String(bytes1 , "gbk");// 解碼,使用的指定的格式
System.out.println(str3);
}
6. StringBuffer、StringBuilder ?
面試題:對比String、StringBuffer、StringBuilder ?
- String(JDK1.0):不可變字元序列 ,效率最低
- StringBuffer(JDK1.0):可變字元序列、效率低、線程安全 同步
- StringBuilder(JDK 5.0):可變字元序列、效率高、線程不安全
- 底層都使用char[]存儲
註意:作為參數傳遞的話,方法內部String不會改變其值,StringBuffer和StringBuilder 會改變其值
源碼分析:
String str = new String(); // char[] value = new char[0];
String str1 = new String("abc"); // char[] value = new char[]{'a','b','c'};
StringBuffer sb1 = new StringBuffer(); // char[] value = new char[16];底層創建一個長度16的char型數組
StringBuffer sb1 = new StringBuffer("abc"); // char[] value = new char["abc".length()+16];
問題1:
註意這個是裡面 裡面數據的長度,
public void test5(){
StringBuffer sb1 = new StringBuffer();
System.out.println(sb1.length()); // 0
StringBuilder sb2 = new StringBuilder("abc");
System.out.println(sb2.length()); // 3
}
問題2:
擴容問題,如果要添加的數據放不下了,那就需要擴容數組,預設情況下,擴容為原來的2倍+2,將原有數組中的數據複製到新的數組中去
String -----> StringBuffer、StringBuilder : 調用StringBuffer、StringBuilder構造器就可以了
StringBuffer、StringBuilder -----> : 調用String的構造器
StringBuffer類的常用方法和StringBuilder類似
- StringBuffer append(xxx):提供了很多的append()方法,用於進行字元串拼接
- StringBuffer delete(int start,int end):刪除指定位置的內容
- StringBuffer replace(int start, int end, String str):把[start,end)位置替換為str
- StringBuffer insert(int offset, xxx):在指定位置插入xxx
- StringBuffer reverse() :把當前字元序列逆轉
- public int indexOf(String str)
- public String substring(int start,int end)
- public int length()
- public char charAt(int n )
- public void setCharAt(int n ,char ch)
總結:
- 增 :append
- 刪:delete
- 改:setCharAt,replace
- 查:charAt
- 插入:insert
- 長度:length
面試題:
public void testStringBuffer(){
String str = null;
StringBuffer sb = new StringBuffer();
sb.append(str);
System.out.println(sb.length()); // 4
System.out.println(sb); // "null" 這個是字元串null
StringBuffer sb1 = new StringBuffer(str); // 拋異常 NullPointerException
System.out.println(sb1);
}