Java基礎—String類

一、String類

1.概述

1）字符串解讀

String s1 = "abc"; s1是一個類類型變量，"abc"是一個對象。只要在""裏的，都是對象。字符串最大的特點在於，一旦初始化，就不可以改變。字符串，既是對象，又是常量。

示例：
String s1 = “abc”;
s1 = “kk”;
System.out.println(s1);

輸出結果爲：kk
變化的不是"abc"這個對象，而是s1這個引用；重新賦值後，s1指向了"kk"這個對象。

2）字符串創建方式的區別

高能：
String s1 = new “abc”;
String s2 = new String(“abc”);
s1和s2的區別在於，s1有一個對象，s2有兩個對象。s2中，new是一個對象，”abc”是一個對象。

小擴展
字符串在內存中有常量池，該常量池是一個數組，用於存儲’a’，’b’，’c’這樣的字符；字符串由字符組成，如果常量池中有’a’，’b’，’c’,’d’，’e’，’f’這些字符，下次創建String s3 = “abf”;的時候，虛擬機會到常量池中找到這三個字符，拼接起來。

3）String類的equals()方法

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

示例：
String s1 = new “abc”;
String s2 = new String(“abc”);
System.out.println(s1.equals(s2));

輸出：true

4）String的“==”操作符比較

示例代碼：

class StringCompare {
    public void main(String[] args) {
        String s1 = "abc";
        String s2 = new String("abc");
        String s3 = "abc";
        System.out.println(s1 == s2);
        System.out.println(s1 == s3);
    }
}

輸出結果爲：

false
true

字符串儲存在常量池當中，當s1創建的時候，"abc"對象已經在內存中存在了；那麼，當s3創建的時候，如果常量池中已經有"abc"字符串的字符，就不會再創建對象，而直接讓s3指向"abc"這個對象。

2.String類中的方法

String類是用於描述字符串這個事物。其常見的方法有：

1）獲取操作

1> 獲取字符串長度：int length()
2> 獲取指定位置上的字符：char charAt(int index)
3> 獲取指定字符的位置有如下方法：

a.int indexOf(int ch)：獲取指定字符第一次出現的位置
b.int indexOf(int ch, int fromIndex)：獲取指定字符從fromIndex位置開始，第一次出現的位置
c.int indexOf(String str)：獲取子字符串第一次出現的位置，也可以用於判斷字符串是否包含指定字符串
d.int indexOf(String str, int fromIndex)：獲取子字符串從fromIndex位置開始，第一次出現的位置
e.int lastIndexOf(char ch)：反向查找指定字符

2）判斷操作

1> 字符串中是否包含子字符串：boolean contains(CharSequence s)
2> 字符串是否長度爲零：boolean isEmpty(String str)
3> 字符串是否以指定字符串開頭：boolean startsWith(String str)
4> 字符串是否以指定字符串結尾：boolean endsWith(String str)

3）轉換操作

1> 將字符數組轉換成字符串：

a.構造方法：
String(char[] ch)：將字符數組轉換成字符串
String(char[] ch, int offset, int count)：將字符數組的一部分轉換成字符串
b.靜態方法：
static String copyValueOf(char[] ch)：將字符數組轉換爲字符串
static String copyValueOf(char[] ch, int offset, int count)：將字符數組的一部分轉換成字符串
static String ValueOf(char[] ch) ：將字符數組轉換爲字符串

2> 將字符串轉換成字符數組：char[] toCharArray()
3> 將字節數組轉換成字符串：

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

4> 將字符串轉換成字節數組：

byte[] getBytes()

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

5> 將基本數據類型轉換成字符串

static String ValueOf(int)
static String ValueOf(double)

4）替換操作

1> 將子字符替換成目標字符：String replace(char oldChar, char newChar) //如果被替換數組不存在，返回原字符串
2> 將子字符串替換成目標字符串：String replace(CharSequence target, CharSequence replecement)

5）切割操作

1> 切割字符串：String[] split(Reg reg)

6）獲取子串

1> 獲取字符串中的子字符串：

String substring(int beginIndex)
String substring(int beginIndex, endIndex) //不存在的下標會出現字符串下標越界異常

7）去除空格，大小寫轉換，字符串比較大小

1> 字符串大小寫轉換

String toUpperCase()
String toLowerCase()

2> 去除字符串兩端多餘空格：String trim()
3> 兩個字符串比較大小：int compareTo(String string)

8）字符串方法代碼示例：

package com.heisejiuhuche.String;

public class StringAPI {
    private static String str = "abcaaddefggut";

    public static void main(String[] args) {
//      get();
//      is();
        trans();
        replace();
        split();
        sub();
        other();
    }

    private static void get() {
        //獲取長度
        print(str.length());
        //根據索引獲取字符
        //下標越界會產生異常
        print(str.charAt(7));
        //根據字符獲取索引
        //找不到目標字符返回-1
        print(str.indexOf('a', 1));
        //反向查找
        print(str.lastIndexOf('e'));
    }

    private static void is() {
        String str = "ExceptionTest.java";
        //判斷是否以Exception開頭
        print(str.startsWith("Exception"));
        //判斷是否以.java結尾
        print(str.endsWith(".java"));
        //判斷是否包含Test
        print(str.contains("Test"));
        //判斷長度是否爲0
        print(str.isEmpty());
    }

    private static void trans() {
        char[] ch = {'a', 'b', 'c', 'd', 'e', 'f', 'g'};
        //字符數組轉字符串
        String str = new String(ch, 2, 3);
        print(str);

        String s1 = "zmsdjlfjxlk";
        //字符串轉字符串數組
        char[] cha = s1.toCharArray();
        for(int x = 0; x < cha.length; x++) {
            print("ch= " + cha[x]);
        }
    }

    private static void replace() {
        String s1 = "hello java";
        //替換目標字符
        String s2 = s1.replace('a', 'n');
        print(s2);
        //替換目標字符串
        String s3 = s1.replace("java", "world");
        print(s3);
    }

    private static void split() {
        String s1 = "zhangsan, lisi, wangwu";
        //切割字符串
        String[] arr = s1.split(",");
        for(int x = 0; x < arr.length; x++) {
            print(arr[x]);
        }
    }

    private static void sub() {
        String s1 = "abcdefg";
        //獲取子字符串
        print(s1.substring(2));
        print(s1.substring(2, 4));
    }

    private static void other() {
        String s1 = "     Hello Java     ";
        //轉小寫
        print(s1.toUpperCase());
        //轉大寫
        print(s1.toLowerCase());
        //去除兩端空格
        print(s1.trim());
        String s2 = "acc";
        String s3 = "aaa";
        //字符串比較大小
        print(s2.compareTo(s3));
    }

    private static void print(Object obj) {
        System.out.println(obj);
    }
}

3.String類練習

1）模擬trim()方法

寫一個trim()方法的模擬方法，去除字符串兩端的空格，返回去除空格後的字符串。

示例代碼：

package com.heisejiuhuche.String;

/**
 * 模擬trim()方法，去除字符串兩端空格
 * @author jeremy
 *
 */

public class StringTest1 {
    public static void main(String[] args) {
        String string = "      abc def g hi      ";
        print("(" + string + ")");
        string = myTrim(string);
        print("(" + string + ")");
    }

    private static String myTrim(String string) {
        int start = 0;
        int end = string.length() - 1;

        //如果從下標0開始的字符爲空格，則繼續往後檢查，直到字符不爲空格
        while(start <= end && (string.charAt(start) == ' ')) {
            start++;
        }

        //如果從字符串結尾開始檢查，字符爲空格，則繼續倒序檢查，直到字符不爲空格
        while(start <= end && (string.charAt(end) == ' ')) {
            end--;
        }

        //返回院字符串的子字符串，注意end要+1，不然丟失最後一個字符
        return string.substring(start, end + 1);
    }

    private static  void print(Object obj) {
        System.out.println(obj);
    }
}

程序輸出結果：

(      abc def g hi      )
(abc def g hi)

2）反轉字符串

將任意字符串反轉輸出。

示例代碼：

package com.heisejiuhuche.String;

public class StringTest2 {
    public static void main(String[] args) {
        String string = "   abcd efg hi     ";
        print("(" + string + ")");
        string = reverseString(string);
        print("(" + string + ")");
    }

    /* 反轉字符串 */
    private static String reverseString(String string) {
        char[] ch = string.toCharArray();
        reverse(ch);
        string = new String(ch);
        return string;
    }

    /* 反轉數組 */
    private static void reverse(char[] ch) {
        for(int start = 0, end = ch.length - 1; start < end; start++, end--) {
            swap(ch, start, end);
        }
    }

    /* 交換元素 */
    private static void swap(char[] ch, int start, int end) {
        char tmp = ch[start];
        ch[start] = ch[end];
        ch[end] = tmp;
    }

    private static  void print(Object obj) {
        System.out.println(obj);
    }
}

程序輸出結果：

(   abcd efg hi     )
(     ih gfe dcba   )

3）反轉指定字符串

將任意字符串中的指定部分反轉輸出。

示例代碼：

package com.heisejiuhuche.String;

public class StringTest3 {
    public static void main(String[] args) {
        String string = "   abcd efg hi     ";
        print("(" + string + ")");
        string = reverseString(string);
        print("(" + string + ")");
    }

    /* 反轉字符串 */
    private static String reverseString(String string) {

        return reverseString(string, 5, 9);
    }

    /* 反轉指定字符串 */
    private static String reverseString(String string, int start, int end) {
        char[] ch = string.toCharArray();
        reverse(ch, start, end);
        string = new String(ch);
        return string;
    }

    /* 反轉數組 */
    private static void reverse(char[] ch, int x, int y) {
        for(int start = x, end = y - 1; start < end; start++, end--) {
            swap(ch, start, end);
        }
    }

    /* 交換元素 */
    private static void swap(char[] ch, int start, int end) {
        char tmp = ch[start];
        ch[start] = ch[end];
        ch[end] = tmp;
    }

    private static  void print(Object obj) {
        System.out.println(obj);
    }
}

程序輸出結果：

(   abcd efg hi     )
(   abe dcfg hi     )

4）獲取一個字符串在另一個字符串中出現的次數

示例代碼：

package com.heisejiuhuche.String;

public class StringTest4 {
    public static void main(String[] args) {
        String str = "kkabkkckkdkkefkkskkdddddkk";
        System.out.println(getSubCount2(str, "kk"));
    }

    /* 方法一，使用indexOf(String str)方法 */
    private static int getSubCount(String str, String key) {
        int count = 0;
        int index = 0;

        /*在str中尋找key，能找到，就繼續往後找，index記錄每次找到key的下標
        下標加上key的長度，就是剩下字符串的起始位置，截取剩下的字符串
        然後在剩下的字符串裏繼續尋找key，直到indexOf()方法返回-1
        最後返回count */
        while((index = str.indexOf(key)) != -1) {
            str = str.substring(index + key.length());
            count++;
        }
        return count;
    }

    /*方法二，使用indexOf(String str, int fromIndex)方法，較高效 
     * index記錄找到key的下標位置，加上key的長度，就是下一次應該開始尋找的下標
     * 讓indexOf()方法直接從這個位置開始尋找即可*/
    private static int getSubCount2(String str, String key) {
        int count = 0;
        int index = 0;

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

程序輸出結果：

7

5）獲取兩個字符串中最大相同子串

在字符串"sdwrtuiohellojavacbsdwrtwtwhdfh";和"dsewrwhellojavadcwry";中，輸出最大相同子串，即hellojava。

示例代碼：

package com.heisejiuhuche.String;

/**
 * 1.先確定較短的字符串；在長字符串中搜索整個較短的字符串；
 * 2.如果沒有匹配，就將較短的字符串長度-1；
 * 3.長度-1之後的較短字符串有兩種情況，末尾減少一個字符，和首部減少一個字符的情況；
 * 4.用substring()方法得到這兩個字符串；這個過程，就是先取0到較短字符串長度-1的子串
 *    再取首尾下標都自增1之後的子串；
 * 5.以此類推，如果這兩個子串還是沒有在較長字符串中找到匹配，就將較短字符串的長度-2；
 * 6.再通過取子串的過程，得到3個子串（0到較短的長度-2，然後下標自增，即1到較短的長度-1，
 *   然後下標再自增，即2到較短的長度），直到尾部下標等於較短字符串長度爲止；
 * 7.每次截取字符串，都判斷這個子串是否能在較長字符串中匹配；
 * 8.外層循環控制循環次數（循環較短字符串的長度次），內循環控制每次要截取的子串個數，並進行匹配
 *   匹配上，返回該子串，匹配不上返回空字符串
 * @author jeremy
 *
 */

public class StringTest5 {
    public static void main(String[] args) {
        String s1 = "sdwrtuiohellojavacbsdwrtwtwhdfh";
        String s2 = "dsewrwhellojavadcwry";
        System.out.println(getMaxSubString(s2, s1));
    }

    private static String getMaxSubString(String s1, String s2) {
        String longer;
        String shorter;

        //如果s1長於s2，longer等於s1
        longer = (s1.length() > s2.length()) ? s1 : s2;
        //如果longer等於s1，那麼s2較短
        shorter = (longer == s1) ? s2 : s1;

        for(int x = 0; x < shorter.length(); x++) {
            for(int y = 0, z = shorter.length() - x; z != shorter.length() + 1; y++, z++) {
                String tmp = shorter.substring(y, z);
                if(longer.contains(tmp)) {
                    return tmp;
                }
            }
        }
        return "";
    }
}

程序運行結果：

hellojava

二、StringBuffer類

1.定義

StringBuffer是一個字符串緩衝區，是一個容器。

2.StringBuffer的特點

1）長度可變；
2）可以用於對字符串進行修改；
2）可以直接操作多個數據類型；
3）最終通過toString()方法輸出字符串

3.StringBuffer的功能

1> 存儲功能

-StringBuffer append()：將指定的數據作爲參數添加到已有數據的結尾處

示例代碼：

StringBuffer sb = new StringBuffer();
sb.append("3").append("sdjfkd").append(sdjfkd);

代碼輸出：3sdjfkdsdjfkd

高能：
連續調用append()方法的現象叫做方法調用鏈；因爲append()方法返回一個StringBuffer對象，對象還能調用本類方法。

-StringBuffer insert(int offset, String str)：在指定位置插入字符串

示例代碼：

StringBuffer sb = new StringBuffer();
sb.append("3").append("sdjfkd").append(true);
sb.insert(1, "qq");

代碼輸出：3qqsdjfkdsdjfkd

注意：
如果插入的下標不存在，會出現字符串下標越界異常。

2> 刪除功能

-StringBuffer delete(int start, int end)：刪除從start開始到end（不包含）技術的字符串

示例代碼：

StringBuffer sb = new StringBuffer("abcde");
sb.delete(1, 3);

代碼輸出：ade

-StringBuffer deleteCharAt(int index)：刪除指定位置的字符串

示例代碼：

StringBuffer sb = new StringBuffer("abcde");
sb.deleteCharAt(2);

代碼輸出：abde

3> 獲取功能

-char charAt(int index)：通過下標獲取字符
-int indexOf(String str)：獲取目標字符串出現的第一個位置
-int lastIndexOf(String str)：反向查找目標字符串出現的第一個位置
-int length()：獲取字符串長度
-String substring(int start, int end)：獲取子串

4> 修改功能

-StringBuffer replace(int start, int end, String str)：將從start開始到end（不包含）結束的字符串替換爲目標字符串

示例代碼：

StringBuffer sb = new StringBuffer("abcde");
sb.replace(1, 4, "java");

代碼輸出：ajavae

-void setCharAt(int index, char ch)：將下標所在字符替換成目標字符

示例代碼：

StringBuffer sb = new StringBuffer("abcde");
sb.setCharAt(2, 'k');

代碼輸出：abkde

-StringBuffer reverse()：反轉字符串
-void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)：將緩衝區中的指定數據存儲到指定數組的指定位置

示例代碼：

StringBuffer sb = new StringBuffer("abcdef");
char[] ch = new char[6];
sb.getChars(1, 4, ch, 1);
for(int x = 0; x < ch.length; x++) {
    System.out.println(ch[x]);
}

代碼輸出：

ch[0] = 
ch[1] = b
ch[2] = c
ch[3] = d
ch[4] = 
ch[5] = 

三、StringBuilder類

1.定義

StringBuilder是一個可變的字符序列，與StringBuffer功能相同，是StringBuffer的一個簡易替換。

2.與StringBuffer的區別

StringBuffer是線程同步的，而StringBuilder不同步，其在多線程情況下會出現安全問題。

3.開發建議

StringBuilder始於JDK5.0，叫StringBuffer而言是一個更新的類。JDK的升級無外乎提升效率，簡化代碼，提高安全性。StringBuilder的出現提高了代碼運行效率。實際開發中，建議使用StringBuilder；需要同步的時候，由開發者自行加鎖，解鎖。

四、基本數據類型包裝類

1.定義

Java視一切爲對象，包括基本數據類型。八種基本數據類型對應着八種基本數據類型的包裝類。包裝類中定義了一些列操作基本數據類型的方法和屬性，便於開發者使用。

2.包裝類的意義

一個int型的數據，有自己的取值範圍，有自己的表現形式，這些相當於是int類型數據的屬性；如何將一個int型數據轉換爲其他進制的表現形式，只有int類型數據自己最清楚。如果將int類型數據封裝爲類，在類中定義進制轉換的方法，這樣操作int類型數據就會很方便。

3.包裝類的應用

包裝類通常用於基本數據類型和字符串之間做轉換。

1）基本數據類型轉換成字符串

示例代碼：
Integer.toString(34);//將34整數轉換爲字符串34`

2）字符串轉換成基本數據類型

示例代碼：
Integer.parseInt(“34”);//將字符串34轉換爲整數34

注意：
-包裝類Character沒有parse方法，因爲其本身就是字符；
-在字符串轉換爲基本數據類型時，傳入了字符，會出現數字格式異常

3）字符串進制表現形式轉換成十進制數

示例代碼：
Integer.parseInt(“110”, 2);//將字符串110作爲二進制數轉爲十進制整數，結果爲6
Integer.parseInt(“3c”, 16)//結果爲60

小擴展
將字符串”123”轉換成int類型數據的另一種方法：
Integer i = new Integer(“123”);
int num = i.intValue();//非靜態方法

4）數字比較：int compareTo(Integer anotherInteger)

4.包裝類新特性

1）JDK5.0版本之後，基本數據類型引入了自動裝箱，自動拆箱的概念，以簡化代碼。

示例代碼：

Integer x = new Integer(4);//這行代碼相當於
Integer x = 4;//自動裝箱，4是Integer對象
x += 2;//可以直接進行運算，先將x自動拆箱，變爲int類型，再進行運算，最後將和自動裝箱

注意：
-自動拆箱的原理是，先執行了x.intValue();得到x的int類型數據，再進行運算；
-如果聲明x爲Integer引用，其值可以被賦爲空（null）；此時如果再進行算數運算，會出現空指針異常；因爲自動拆箱時，需要調用intValue()方法，而x = null;程序出錯

前方高能：Integer取值範圍（面試用）

示例代碼：
Integer m = 128;
Integer n = 128;
System.out.println(“m == n: ” + (m == n));

代碼輸出：false

示例代碼：
Integer a = 127;
Integer b = 127;
System.out.println(“a == b: ” + (a == b));

代碼輸出：true

因爲a和b指向同一個Integer對象。當數值在byte範圍內時，如果該數值已經存在，包裝類新特性就不會再開闢新的內存空間。