經常使用API - 字符串

時間 2020-06-20

標籤經常使用 api 字符串简体版

原文原文鏈接

String類

java.lang.String類表明字符串java

Java 程序中的全部字符串字面值（如 "abc" ）都做爲此類的實例實現。正則表達式

特色編程

字符串的內容不可變！！
由於 String 對象是不可變的，因此能夠共享。
字符串效果上至關因而char[]字符數組，但底層原理是byte[]字節數組（JDK9）

構造方法

構造方法	說明
String() *	初始化一個新建立的 String 對象，使其表示一個空字符序列。
String(byte[] bytes) *	經過使用平臺的默認字符集解碼指定的 byte 數組，構造一個新的 String。
String(char[] value) *	分配一個新的 String，使其表示字符數組參數中當前包含的字符序列。
String(String original)	初始化一個新建立的 String 對象，使其表示一個與參數相同的字符序列；換句話說，新建立的字符串是該參數字符串的副本。
String(byte[] bytes, int offset, int length)	經過使用平臺的默認字符集解碼指定的 byte 子數組，構造一個新的 String。
String(byte[] bytes, Charset charset)	經過使用指定的 charset 解碼指定的 byte 數組，構造一個新的 String。
String(byte[] bytes, int offset, int length, Charset charset)	經過使用指定的 charset 解碼指定的 byte 子數組，構造一個新的 String。
String(byte[] bytes, int offset, int length, String charsetName)	經過使用指定的字符集解碼指定的 byte 子數組，構造一個新的 String。
String(byte[] bytes, String charsetName)	經過使用指定的 charset 解碼指定的 byte 數組，構造一個新的 String。
String(char[] value, int offset, int count)	分配一個新的 String，它包含取自字符數組參數一個子數組的字符。
String(int[] codePoints, int offset, int count)	分配一個新的 String，它包含 Unicode 代碼點數組參數一個子數組的字符。
String(StringBuffer buffer) *	分配一個新的字符串，它包含字符串緩衝區參數中當前包含的字符序列。
String(StringBuilder builder) *	分配一個新的字符串，它包含字符串生成器參數中當前包含的字符序列。

package com;

public class StringTest {
    public static void main(String[] args) {
        // 常見建立字符串的3+1的方式
        String str1 = new String();
        System.out.println("第一種無參構造方法建立字符串："+str1);

        char[] array = {'A','B','C'};
        String str2 = new String(array);
        System.out.println("第二種傳入字符數組建立字符串："+str2);

        byte[] array2 = {65,66,67};
        String str3 = new String(array2);
        System.out.println("第三種傳入字節數組建立字符串："+str3);

        String str = "hello";
        System.out.println("直接建立字符串:"+str);
    }
}

注意數組

直接用雙引號建立的字符串，JVM會自動將它new成字符串對象

字符串常量池

程序當中直接寫上雙引號的字符串，存在字符串常量池中app

package com;

public class StringPool {
    public static void main(String[] args) {
        String str1 = "123";
        String str2 = "123";

        char[] charArray = {'1', '2', '3'};
        String str3 = new String(charArray);

        System.out.println(str1 == str2);
        System.out.println(str1 == str3);
        System.out.println(str2 == str3);
    }
}

結果測試

true
false
false

示意圖ui

注意編碼

對於基本類型 --> 兩個等號是比較【數值】是否相等
對於引用類型 --> 兩個等號是比較【地址值】是否相等
直接用雙引號建立的字符串會先到常量池看存不存在，字符串共享
使用new建立的字符串與常量池無關，會在堆中開闢新的空間

經常使用方法

方法摘要	描述
int length()	返回此字符串的長度。
boolean equals(Object anObject)	將此字符串與指定的對象比較。（只有參數是同類型且內容相同才返回true）
boolean equalsIgnoreCase(String anotherString)	將此 String 與另外一個 String 比較，不考慮大小寫。
char charAt(int index)	返回指定索引處的 char 值。
String concat(String str)	將指定字符串鏈接到此字符串的結尾。
int indexOf(String str)	返回指定子字符串在此字符串中第一次出現處的索引。
String substring(int beginIndex)	返回一個新的字符串，它是此字符串的一個子字符串。
String substring(int beginIndex, int endIndex)	返回一個新字符串，它是此字符串的一個子字符串。（左閉右開）
char[] toCharArray()	將此字符串轉換爲一個新的字符數組。
byte[] getBytes()	使用平臺的默認字符集將此 String 編碼爲 byte 序列，並將結果存儲到一個新的 byte 數組中。
byte[] getBytes(Charset charset)	使用給定的 charset 將此 String 編碼到 byte 序列，並將結果存儲到新的 byte 數組。
byte[] getBytes(String charsetName)	使用指定的字符集將此 String 編碼爲 byte 序列，並將結果存儲到一個新的 byte 數組中。
String replace(char oldChar, char newChar)	返回一個新的字符串，它是經過用 newChar 替換此字符串中出現的全部 oldChar 獲得的。
String replace(CharSequence target, CharSequence replacement)	使用指定的字面值替換序列替換此字符串全部匹配字面值目標序列的子字符串。
String replaceFirst(String regex, String replacement)	使用給定的 replacement 替換此字符串匹配給定的正則表達式的第一個子字符串。
String replaceAll(String regex, String replacement)	使用給定的 replacement 替換此字符串全部匹配給定的正則表達式的子字符串。
String trim()	返回字符串的副本，忽略前導空白和尾部空白。
String[] split(String regex)	根據給定正則表達式的匹配拆分此字符串。
String[] split(String regex, int limit)	根據匹配給定的正則表達式來拆分此字符串。
boolean endsWith(String suffix)	測試此字符串是否以指定的後綴結束。
boolean startsWith(String prefix)	測試此字符串是否以指定的前綴開始。
boolean startsWith(String prefix, int toffset)	測試此字符串從指定索引開始的子字符串是否以指定前綴開始。
int compareTo(String anotherString)	按字典順序比較兩個字符串。
int compareToIgnoreCase(String str)	按字典順序比較兩個字符串，不考慮大小寫。
boolean contains(CharSequence s)	當且僅當此字符串包含指定的 char 值序列時，返回 true。

查找方法

查找方法	描述
int indexOf(int ch)	返回指定字符在此字符串中第一次出現處的索引。
int indexOf(int ch, int fromIndex)	返回在此字符串中第一次出現指定字符處的索引，從指定的索引開始搜索。
int indexOf(String str)	返回指定子字符串在此字符串中第一次出現處的索引。
int indexOf(String str, int fromIndex)	返回指定子字符串在此字符串中第一次出現處的索引，從指定的索引開始。
int lastIndexOf(int ch)	返回指定字符在此字符串中最後一次出現處的索引。
int lastIndexOf(int ch, int fromIndex)	返回指定字符在此字符串中最後一次出現處的索引，從指定的索引處開始進行反向搜索。
int lastIndexOf(String str)	返回指定子字符串在此字符串中最右邊出現處的索引。
int lastIndexOf(String str, int fromIndex)	返回指定子字符串在此字符串中最後一次出現處的索引，從指定的索引開始反向搜索。

indexOf 和 lastIndexOf的多種重載方法指針

轉換方法

轉換方法	描述
String toLowerCase()	使用默認語言環境的規則將此 String 中的全部字符都轉換爲小寫。
String toLowerCase(Locale locale)	使用給定 Locale 的規則將此 String 中的全部字符都轉換爲小寫。
String toUpperCase()	使用默認語言環境的規則將此 String 中的全部字符都轉換爲大寫。
String toUpperCase(Locale locale)	使用給定 Locale 的規則將此 String 中的全部字符都轉換爲大寫。
static String valueOf(boolean b)	返回 boolean 參數的字符串表示形式。
static String valueOf(char c)	返回 char 參數的字符串表示形式。
static String valueOf(char[] data)	返回 char 數組參數的字符串表示形式。
static String valueOf(char[] data, int offset, int count)	返回 char 數組參數的特定子數組的字符串表示形式。
static String valueOf(double d)	返回 double 參數的字符串表示形式。
static String valueOf(float f)	返回 float 參數的字符串表示形式。
static String valueOf(int i)	返回 int 參數的字符串表示形式。
static String valueOf(long l)	返回 long 參數的字符串表示形式。
static String valueOf(Object obj)	返回 Object 參數的字符串表示形式。
char[] toCharArray()	將此字符串轉換爲一個新的字符數組。
byte[] getBytes()	使用平臺的默認字符集將此 String 編碼爲 byte 序列，並將結果存儲到一個新的 byte 數組中。

其餘方法

其餘方法	描述
String intern()	返回字符串對象的規範化表示形式。
boolean isEmpty()	當且僅當 length() 爲 0 時返回 true。
int codePointAt(int index)	返回指定索引處的字符（Unicode 代碼點）。
int codePointBefore(int index)	返回指定索引以前的字符（Unicode 代碼點）。
int codePointCount(int beginIndex, int endIndex)	返回此 String 的指定文本範圍中的 Unicode 代碼點數。
boolean contentEquals(CharSequence cs)	將此字符串與指定的 CharSequence 比較。
boolean contentEquals(StringBuffer sb)	將此字符串與指定的 StringBuffer 比較。
static String copyValueOf(char[] data)	返回指定數組中表示該字符序列的 String。
static String copyValueOf(char[] data, int offset, int count)	返回指定數組中表示該字符序列的 String。
static String format(Locale l, String format, Object... args)	使用指定的語言環境、格式字符串和參數返回一個格式化字符串。
static String format(String format, Object... args)	使用指定的格式字符串和參數返回一個格式化字符串。
void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)	將字符今後字符串複製到目標字符數組。
int hashCode()	返回此字符串的哈希碼。
boolean matches(String regex)	告知此字符串是否匹配給定的正則表達式。
int offsetByCodePoints(int index, int codePointOffset)	返回此 String 中從給定的 index 處偏移 codePointOffset 個代碼點的索引。
boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len)	測試兩個字符串區域是否相等。
boolean regionMatches(int toffset, String other, int ooffset, int len)	測試兩個字符串區域是否相等。
CharSequence subSequence(int beginIndex, int endIndex)	返回一個新的字符序列，它是此序列的一個子序列。

案例

package com;

/**
 * equals方法的使用
 * equalsIgnoreCase 忽略大小寫的比較
 */
public class StringEquals {
    public static void main(String[] args) {
        String str1 = "Hello";
        String str2 = "Hello";
        char[] array = {'H', 'e', 'l', 'l', 'o'};
        String str3 = new String(array);

        System.out.println(str1.equals(str3));
        System.out.println(str2.equals(str3));
        System.out.println(str3.equals("Hello"));
        System.out.println("Hello".equals(str3));
        // 推薦常量字符串寫在前面。變量寫前面可能會出現空指針異常

        System.out.println("=============");
        String str4 = "hello";
        System.out.println(str3.equals(str4));
        // 忽略大小寫
        System.out.println(str3.equalsIgnoreCase(str4));

    }
}

注意事項code

任何對象均可以用Object進行接收
equals方法具備對稱性！即 a.equals(b) 和 b.equals(a)效果同樣
若是一個常量和一個變量比較，推薦把常量字符串寫在前面！

package com;

/**
 * length() 返回長度
 * concat 拼接
 * charAt 獲取指定索引位置的單個字符
 * indexOf 查找首次出現的索引位置，無返回-1
 */
public class StringGet {
    public static void main(String[] args) {
        System.out.println("Hello world".length());

        // 拼接字符串 （String不可變！！）
        String str1 = "Hello";
        String str2 = "World";
        String str3 = str1.concat(str2);
        System.out.println(str1); // 原封不動
        System.out.println(str2); // 原封不動
        System.out.println(str3); // 新的字符串

        // 獲取指定索引位置的單個字符
        System.out.println("Hello在0號索引位置的字符是："+"Hello".charAt(0));
        System.out.println("Hello在4號索引位置的字符是："+"Hello".charAt(4));

        // 查詢參數字符串在原字符串當中出現的第一次索引位置
        System.out.println();
        String strA = "Hello World Hello1";
        System.out.println(strA.indexOf("hello")); // 查不到返回 -1
        System.out.println(strA.indexOf("Hello1"));// 首次出現的索引

    }
}

package com;

/**
 * 字符的截取方法
 * substring(int index)
 * substring(int begin, int end) 【b,n)左閉右開
 *
 */
public class StringSub {
    public static void main(String[] args) {
        String str1 = "HelloWorld";
        String str2 = str1.substring(5);
        // 字符串不能發生改變，每當對原值操做就是生產新的字符串
        System.out.println(str1);
        System.out.println(str2);

        String str3 = str1.substring(4, 7);
        // 左閉右開
        System.out.println(str3);

    }
}

package com;

/**
 * 轉換相關的方法
 * toCharArray[] 將當前字符串拆分爲字符數組
 * getBytes() 得到當前字符串的底層字節數組
 * replace替換
 * valueOf 轉換成字符串
 *
 */
public class StringConvert {
    public static void main(String[] args) {
        char[] chars = "Hello".toCharArray();
        System.out.println(chars[0]);
        System.out.println(chars.length);
        System.out.println("===========");

        // IO常常用的字節流寫入
        byte[] bytes = "abc".getBytes();
        for (byte b : bytes) {
            System.out.print(b + "\t");
        }
        System.out.println();

        String str1 = "Hi boy";
        String str2 = str1.replace("boy", "girl");
        System.out.println(str1);
        System.out.println(str2);
        System.out.println("===========");
        
        // 八大基本數據類型轉換爲字符串
        int num = 123;
        double d = 999.999;
        boolean b = false;
        char ch = 'a';

        System.out.println(String.valueOf(num));
        System.out.println(String.valueOf(d));
        System.out.println(String.valueOf(b));
        System.out.println(String.valueOf(ch));
        
    }
}

package com;

/**
 * 分割方法split
 * String[] split(String regex)
 * split 的參數 regex是一個正則表達式
 * 英文句點「.」 寫成「\\.」
 */
public class StringSplit {
    public static void main(String[] args) {
        String str1 = "1,2,3,4,5";
        System.out.println(str1);
        String[] array1 = str1.split(",");
        for (int i = 0; i < array1.length; i++) {
            System.out.print(array1[i] + "\t");
        }
        System.out.println();

        // 特殊！！使用英文句號時（.） 須要加兩個反斜槓
        String str2 = "x.y.z";
        //String[] array2 = str2.split("."); // 直接用英文點不行
        String[] array2 = str2.split("\\.");
        System.out.println("長度爲：" + array2.length);
        for (String s : array2) {
            System.out.print(s + "\t");
        }

    }
}

練習

定義一個方法，吧數組{1,2,3}按指定格式拼接成一個字符串。格式參照以下；[word1#word2$word3]

package com.practise;

/**
 * 定義一個方法，吧數組{1,2,3}按指定格式拼接成一個字符串。
 * 格式參照以下；[word1#word2$word3]
 */
public class StringPractise {
    public static void main(String[] args) {
        int[] nums = {1, 2, 3};
        System.out.println(fromArrayToString(nums));
    }

    public static String fromArrayToString(int[] array) {
        String result = "[";
        for (int i = 0; i < array.length; i++) {
            if (i != array.length - 1) {
                result += "word" + array[i] + "#";
            } else {
                result += "word" + array[i];
            }
        }
        result += "]";
        return result;
    }
}

鍵盤輸入一個字符串，而且統計其中各類字符出現的次數。

種類有：大寫字母、小寫字母、數字、其餘

package com.practise;

import java.util.Scanner;

/**
 * 鍵盤輸入一個字符串，而且統計其中各類字符出現的次數。
 * 種類有：大寫字母、小寫字母、數字、其餘
 */
public class StringPractise2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("請輸入一個字符串：");
        String str = sc.nextLine();
        char[] chars = str.toCharArray();
        int[] count = {0, 0, 0, 0,};
        for (char c : chars) {
            if (c >= 'A' && c <= 'Z') {
                count[0]++;
            } else if (c >= 'a' && c <= 'z') {
                count[1]++;
            } else if (c >= '0' && c <= '9') {
                count[2]++;
            } else {
                count[3]++;
            }
        }

        System.out.print("大寫字母、小寫字母、數字、其餘依次出現次數：");
        for (int i : count) {
            System.out.print(i + "\t");
        }
    }

}

StringBuilder類

字符串拼接問題

因爲String類的對象內容不可改變，因此每當進行字符串拼接時，老是會在內存中建立一個新的對象。例如：

public class StringDemo {
    public static void main(String[] args) {
        String s = "Hello";
        s += "World";
        System.out.println(s);
    }
}

在API中對String類有這樣的描述：字符串是常量，它們的值在建立後不能被更改。

根據這句話分析咱們的代碼，其實總共產生了三個字符串，即"Hello"、"World"和"HelloWorld"。

引用變量s首先指向Hello對象，最終指向拼接出來的新字符串對象，即HelloWord 。

由此可知，若是對字符串進行拼接操做，每次拼接，都會構建一個新的String對象，既耗時，又浪費空間。

爲了解決這一問題，可使用java.lang.StringBuilder類。

StringBuilder概述

查閱java.lang.StringBuilder的API，StringBuilder又稱爲可變字符序列，它是一個相似於 String 的字符串緩衝區，

經過某些方法調用能夠改變該序列的長度和內容。

原來StringBuilder是個字符串的緩衝區，即它是一個容器，容器中能夠裝不少字符串。而且可以對其中的字符串進行各類操做。

它的內部擁有一個數組用來存放字符串內容，進行字符串拼接時，直接在數組中加入新內容。

StringBuilder會自動維護數組的擴容。原理以下圖所示：(默認16字符空間，超過自動擴充)

構造方法

根據StringBuilder的API文檔，經常使用構造方法有2個：

public StringBuilder()：構造一個空的StringBuilder容器。
public StringBuilder(String str)：構造一個StringBuilder容器，並將字符串添加進去。

方法	描述
StringBuilder()	構造一個不帶任何字符的字符串生成器，其初始容量爲 16 個字符。
StringBuilder(int capacity)	構造一個不帶任何字符的字符串生成器，其初始容量由 capacity 參數指定。
StringBuilder(CharSequence seq)	構造一個字符串生成器，它包含與指定的 CharSequence 相同的字符。
StringBuilder(String str)	構造一個字符串生成器，並初始化爲指定的字符串內容。

package com;

/**
 * 字符串緩衝區，能夠提升字符串的效率
 */
public class StringBuilderTest {
    public static void main(String[] args) {
        // 無參構造
        StringBuilder sb = new StringBuilder();
        System.out.println(sb);
        System.out.println(sb.length());

        // 構造一個字符串生成器，並初始化爲指定的字符串內容。
        StringBuilder sb2 = new StringBuilder("Hello");
        System.out.println(sb2);
    }
}

經常使用方法

StringBuilder經常使用的方法有2個：

public StringBuilder append(...)：添加任意類型數據的字符串形式，並返回當前對象自身。
public String toString()：將當前StringBuilder對象轉換爲String對象。

append方法

append方法具備多種重載形式，能夠接收任意類型的參數。任何數據做爲參數都會將對應的字符串內容添加到StringBuilder中。例如：

package com;

/**
 * 經常使用方法
 * append 添加任意類型數據的字符串形式，並返回當前對象自身
 * 可鏈式添加！sb.append("hello").append("world");
 */
public class StringBuilderTest {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        System.out.println("調用append方法前，sb的值：" + sb);
        sb.append("world");
        System.out.println("調用append方法後，sb的值：" + sb);


        StringBuilder builder = new StringBuilder();
        // 能夠添加 任何類型
        builder.append("hello ");
        builder.append("world ");
        builder.append(true);
        builder.append(100);
        // 鏈式編程
        builder.append("\n---------\n").append("world ").append(true).append(100);
        System.out.println("builder:"+builder);
    }
}

備註：StringBuilder已經覆蓋重寫了Object當中的toString方法。

toString方法

經過toString方法，StringBuilder對象將會轉換爲不可變的String對象。如：

package com;

/**
 * StringBuilder 和 String 之間的轉換
 * String -> StringBuilder  ： new StringBuilder("字符串")
 * StringBuilder -> String  ： toString()
 */
public class StringBuilderTest2 {
    public static void main(String[] args) {
        String str = "hello";
        System.out.println(str);

        StringBuilder sb = new StringBuilder(str);
        sb.append(" world");
        System.out.println(sb);

        String s = sb.toString();
        System.out.println(s);

    }
}

方法自查

方法	描述
int capacity()	返回當前容量。
char charAt(int index)	返回此序列中指定索引處的 char 值。
StringBuilder reverse()	將此字符序列用其反轉形式取代。
StringBuilder deleteCharAt(int index)	移除此序列指定位置上的 char。
StringBuilder delete(int start, int end)	移除此序列的子字符串中的字符。
StringBuilder append(int i)	將 int 參數的字符串表示形式追加到此序列。
StringBuilder append(boolean b)	將 boolean 參數的字符串表示形式追加到序列。
StringBuilder append(char c)	將 char 參數的字符串表示形式追加到此序列。
StringBuilder append(char[] str)	將 char 數組參數的字符串表示形式追加到此序列。
StringBuilder append(char[] str, int offset, int len)	將 char 數組參數的子數組的字符串表示形式追加到此序列。
StringBuilder append(CharSequence s)	向此 Appendable 追加到指定的字符序列。
StringBuilder append(CharSequence s, int start, int end)	將指定 CharSequence 的子序列追加到此序列。
StringBuilder append(double d)	將 double 參數的字符串表示形式追加到此序列。
StringBuilder append(float f)	將 float 參數的字符串表示形式追加到此序列。
StringBuilder append(long lng)	將 long 參數的字符串表示形式追加到此序列。
StringBuilder append(Object obj)	追加 Object 參數的字符串表示形式。
StringBuilder append(String str)	將指定的字符串追加到此字符序列。
StringBuilder append(StringBuffer sb)	將指定的 StringBuffer 追加到此序列。
StringBuilder appendCodePoint(int codePoint)	將 codePoint 參數的字符串表示形式追加到此序列。
int codePointAt(int index)	返回指定索引處的字符（統一代碼點）。
int codePointBefore(int index)	返回指定索引前的字符（統一代碼點）。
int codePointCount(int beginIndex, int endIndex)	返回此序列指定文本範圍內的統一代碼點。
void ensureCapacity(int minimumCapacity)	確保容量至少等於指定的最小值。
void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)	將字符今後序列複製到目標字符數組 dst。
int indexOf(String str)	返回第一次出現的指定子字符串在該字符串中的索引。
int indexOf(String str, int fromIndex)	從指定的索引處開始，返回第一次出現的指定子字符串在該字符串中的索引。
StringBuilder insert(int offset, boolean b)	將 boolean 參數的字符串表示形式插入此序列中。
StringBuilder insert(int offset, char c)	將 char 參數的字符串表示形式插入此序列中。
StringBuilder insert(int offset, char[] str)	將 char 數組參數的字符串表示形式插入此序列中。
StringBuilder insert(int index, char[] str, int offset, int len)	將數組參數 str 子數組的字符串表示形式插入此序列中。
StringBuilder insert(int dstOffset, CharSequence s)	將指定 CharSequence 插入此序列中。
StringBuilder insert(int dstOffset, CharSequence s, int start, int end)	將指定 CharSequence 的子序列插入此序列中。
StringBuilder insert(int offset, double d)	將 double 參數的字符串表示形式插入此序列中。
StringBuilder insert(int offset, float f)	將 float 參數的字符串表示形式插入此序列中。
StringBuilder insert(int offset, int i)	將 int 參數的字符串表示形式插入此序列中。
StringBuilder insert(int offset, long l)	將 long 參數的字符串表示形式插入此序列中。
StringBuilder insert(int offset, Object obj)	將 Object 參數的字符串表示形式插入此字符序列中。
StringBuilder insert(int offset, String str)	將字符串插入此字符序列中。
int lastIndexOf(String str)	返回最右邊出現的指定子字符串在此字符串中的索引。
int lastIndexOf(String str, int fromIndex)	返回最後一次出現的指定子字符串在此字符串中的索引。
int length()	返回長度（字符數）。
int offsetByCodePoints(int index, int codePointOffset)	返回此序列中的一個索引，該索引是從給定 index 偏移 codePointOffset 個代碼點後獲得的。
StringBuilder replace(int start, int end, String str)	使用給定 String 中的字符替換此序列的子字符串中的字符。
void setCharAt(int index, char ch)	將給定索引處的字符設置爲 ch。
void setLength(int newLength)	設置字符序列的長度。
CharSequence subSequence(int start, int end)	返回一個新字符序列，該字符序列是此序列的子序列。
String substring(int start)	返回一個新的 String，它包含此字符序列當前所包含字符的子序列。
String substring(int start, int end)	返回一個新的 String，它包含此序列當前所包含字符的子序列。
String toString()	返回此序列中數據的字符串表示形式。
void trimToSize()	嘗試減小用於字符序列的存儲空間。

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。