Java字串詳解
阿新 • • 發佈：2018-12-14
字串(String)是一系列的字元(char)。例如“Hello”是5個字元。字串是一個不可變的物件，也就是說一旦建立就不能被修改。
字串的建立
字串建立有兩種方式：
-
字串字面量
String str1 = "Welcome";字串是物件，雖然我們在這裡沒有用new建立物件，其實是編譯器給我們做了這些操作。這種建立的字串物件有一個特點，如果同樣的物件如果存在了，就不會建立一個新的物件，而是指向了同樣的物件。例如
String str2 = "Welcome";，則str1和str2是指向了字串池中同樣的記憶體地址。 -
new建立字串
String str1 = new String("Welcome");用new關鍵字建立的字串每次都會建立一個新的物件。
注意點：
String str = new String("World");會產生幾個物件？ 如果字串池裡面沒有“World”物件，會在字串池裡面生成一個物件，然後再生成一個字串物件，str指向這個物件；如果字串池裡面已經有了“World”物件，則只會生成一個物件，str指向這個物件。
String常用方法
字串某個位置的字元 charAt(int index)
引數的索引從0開始，到str.length() - 1 為止。 如果不在這個範圍則會丟擲IndexOutOfBoundsException異常。
String str = "Hello world!"; str.charAt(0); // H str.charAt(1); // e
字串是否相等比較 == && equals(Object obj) && equalsIgnoreCase(String string)
==是記憶體的地址的比較；equals首先會用==比較，比較區分字串的大小寫,equalsIgnoreCase也會先用會用==比較，但是不區分大小寫。
String str1 = "Hello world!"; String str2 = "Hello World!"; System.out.println(str1 == str2); // false System.out.println(str1.equal(str2)); // false System.out.println(str1. equalsIgnoreCase(str2)); // false
字串大小比較 compareTo(String string): && compareToIgnoreCase(String string)
compareTo會用每個字元的Unicode進行比較，如果第一個字串比第二個字串大就返回正數，否則返回負數，如果一樣則返回0。
String str1 = "Hello world!";
String str2 = "Hello World!";
System.out.println(str1.compareTo(str2)); // w比W的Unicode編碼大32 結果為32
System.out.println(str1.compareToIgnoreCase(str2)); // 不區分大小寫則相等，結果為0
字串的字首 startsWith(String prefix) 子字串的字首 startsWith(String prefix, int offset)
String str = "Hello world!";
System.out.println(str.startsWith("Hello")); // 子字串(Hello world!)的字首是(Hello) ---> true
System.out.println(str.startsWith("wor", 6)); // 子字串(world!)的字首是(wor) ---> true
字串的字尾 endsWith(String suffix)
String str = "Hello world!";
System.out.println(str.endsWith("world!")); // 子字串(Hello world!)的字尾是(world!) ---> true
是否含有某個字串 contains(CharSequence s)
String str = "Hello world!";
System.out.println(str.contains("a")); // false
字元出現的位置 indexOf(int ch) && indexOf(int ch, int fromIndex) && lastIndexOf(int ch) && lastIndexOf(int ch, int fromIndex)
如果找到返回索引位置，沒找到返回-1.
String str = "Hello world!";
// 從前完後找字元的位置
System.out.println(str.indexOf("o")); // 4
System.out.println(str.indexOf("O")); // -1
// 從某個位置開始從前往後找字元的位置
// 注意：需要注意索引依然是從字串的0開始，不是從開始檢索的位置開始
System.out.println(str.indexOf("o", 6)); // 7
// 從後往前找字串的位置
System.out.println(str.lastIndexOf("o")); // 7
// 從某個索引位置開始從後往前找字元的位置
System.out.println(str.lastIndexOf("o", 6)); // 4
字串出現的位置 indexOf(String str) && lastindexOf(String str)
String str = "Hello world!";
System.out.println(str.indexOf("llo")); // 2
System.out.println(str.lastIndexOf("wor")); // 6
子串 substring(int beginIndex) && substring(int beginIndex, int endIndex)
beginIndex 不能小於0，endIndex不能大於最大索引值。且beginIndex必須小於等於endIndex。
String str = "Hello world!";
System.out.println(str.substring(6)); // 從索引6開始到最後 ---> world!
System.out.println(str.substring(6, 6)); // 從索引6開始到索引9 ---> wor
字串拼接一 concat(String str)
System.out.println("Hello".concat(" ").concat("world!")); // Hello world!
字串拼接二 join(CharSequence delimiter, CharSequence... elements)
這是一個靜態方法，第一引數是分隔符，後面是多個字串，用分隔符拼接起來
String str = String.join(" ", "This", "is", "a", "String"); // This is a String
字元的替換 replace(char oldChar, char newChar) && replace(CharSequence target, CharSequence replacement)
String str = "Hello world!";
// 把字串中某個字元都替換成新的字元。
System.out.println(str.replace("o", "a")); // Hella warld!
// 把字串中某個字串都替換成新的字串。
System.out.println(str.replace("llo", "")); // He world!
正則表示式的替換 replaceFirst(String regex, String replacement) && replaceAll(String regex, String replacement)
replaceAll 和 replaceFirst都是用正則表示式去匹配替換的；replace是直接字串替換
String str = "Telephone is 15512345678";
System.out.println(str.replaceFirst("\\d", "*")); // Telephone is *5512345678
System.out.println(str.replaceAll("\\d", "*")); // Telephone is ***********
大寫 toUpperCase() && 小寫 toLowerCase()
String str = "Hello world!";
System.out.println(str.toUpperCase()); // HELLO WORLD!
System.out.println(str.toLowerCase()); // hello world!
字串複用和初始化 intern()
String str1 = "Hello world!"; // 此時或在字串池中建立一個"Hello world!"字串
String str2 = new String("Hello world!").intern(); // 先在字串池找"Hello world!"，找到就賦值給str2，沒有找到就初始化一個新的賦值給str2
System.out.println(str1.equals(str2)); // 相同
是否是空字串
String str = "";
System.out.println(str.isEmpty()); // true
字串拆分 split(String regex, int limit) && split(String regex)
split的第一個引數regex是一個正則表示式，第二個引數是返回分割的子字串的最大值。預設是傳0，就是不限制個數，所有子字串都返回。
String str = "2018/01/01";
String[] array = str.split("/");
for(int i = 0; i < array.length; i++) {
System.out.println(array[i]); // 2018 01 01
}
字串格式化 format(String format, Object... args)
String str1 = "Welcome";
String str2 = "Johnny";
// %1$s 代表引數1，%2$s 代表引數二，以此類推。。。
String formateStr = String.format("Format String is: %1$s and %1$s, %2$s", str1, str2);
System.out.println(formateStr); // Format String is: Welcome and Welcome, Johnny
String formateStr2 = String.format("My String is %.6f", 12.12);
System.out.println(formateStr2); // My String is 12.120000
去掉收尾空格
String str = " Welcome ";
System.out.println(str.trim()); //Welcome 去掉了首位的空格
生成字元陣列 char[] toCharArray()
String str = "Welcome";
char[] arr = str.toCharArray(); // ["W","e","l","c","o","m","e"]
根據字元陣列生成字串 copyValueOf(char[] data) && copyValueOf(char[] data, int offset, int count)
char[] data = {'a','b','c','d','e','f','g','h','i','j','k'};
String str1 = "Original1";
String str2 = "Original2";
str1 = str1.copyValueOf(data); // 取所有的陣列元素
System.out.println("str1 after copy: " + str1); // str1 after copy: abcdefghijk
str2 = str2.copyValueOf(data, 5, 3); //從第5個索引開始，取3個數組元素
System.out.println("str2 after copy: " + str2); // str2 after copy: fgh
把其他的型別資料變成字串 valueOf() 或者用建構函式new String()
public static String valueOf(boolean b): Used for converting boolean value to a String
public static String valueOf(char c): char to String
public static String valueOf(int i): int to String
public static String valueOf(long l): long to String
public static String valueOf(float f): float to String
public static String valueOf(double d): double to String
int i = 10; //int型別
float f = 10.10f; //float型別
long l = 111L; //long型別
double d = 2222.22; //double型別
char ch = 'A'; //char型別
char array[] = {'a', 'b', 'c'}; //char陣列型別
//把int變成字串
String str1 = String.valueOf(i);
//把float變成字串
String str2 = String.valueOf(f);
//把long變成字串g
String str3 = String.valueOf(l);
//把double變成字串
String str4 = String.valueOf(d);
//把char變成字串
String str5 = String.valueOf(ch);
//把char array變成字串
String str6 = String.valueOf(array);
把字串變成位元陣列 byte[] getBytes()
String擴充套件
String && StringBuffer && StringBuilder
StringBuffer 和 StringBuilder 都可以認為是可變的字串。但是他們之間有一個區別就是 StringBuffer 是執行緒安全的而StringBuilder不是執行緒安全的。所以如果多執行緒操作需要用StringBuffer，而單執行緒操作建議使用StringBuilder，因為它更高效。
String 與 StringBuffer 和 StringBuilder 的區別是 不可變。
StringBuilder builder = new StringBuilder("Hello ");
builder.append("World!");
System.out.println(builder.toString()); // Hello world!
字串轉成int Integer.parseInt() && Integer.valueOf()
需要保證字串能轉成整形，否則會丟擲NumberFormatException異常。
System.out.println(Integer.parseInt("22"));
System.out.println(Integer.valueOf("22"));
int轉成字串 Integer.toString() && valueof() && format()
Integer.toString(22)
字串轉成dobule Double.parseDouble(String) && Double.valueOf(String)
需要保證字串能轉成dobule，否則會丟擲NumberFormatException異常。
System.out.println(Double.parseDouble("22.22"));
System.out.println(Double.valueOf("22.22"));
dobule轉成字串 Double.toString() && valueof() && format()
Double.toString(22.22);
字串轉成long Long.parseLong() && Long.valueOf(String)
System.out.println(Long.parseLong("22"));
System.out.println(Long.parseLong("22"));
long轉成 字串 Long.toString() && valueof() && format()
Long.toString(200)
字串轉成Boolean Boolean valueOf(String s)
Boolean bobj = Boolean.valueOf("false");
Boolean轉成字串 Boolean.toString(boolean b) && String.valueOf(boolean b) && format()
String str = Boolean.toString(false);
Date 和 String的相互轉換
DateFormat format = new SimpleDateFormat("dd-MM-yyyy HH:mm:ss");
String dateString = "02-04-2018 23:30:00";
Date todaysDate = new Date();
try {
// 把字串變成日期
System.out.println(format.parse(dateString));
// 把日期變成字串
System.out.println(format.format(todaysDate));
} catch (ParseException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}