# String
`String`是一个引用类型，它本身也是一个`class`。但是，Java编译器对`String`有特殊处理，即可以直接用`"..."`来表示一个字符串。实际上字符串在`String`内部是通过一个`char[]`数组表示的。因为`String`太常用了，所以提供了`"..."`这种字符串字面量表示方法。
```java
String s1 = "hahaha";
String s2 = new String(new char[]{'h', 'a', 'h', 'a', 'h', 'a'});
```
字符串的一个重要特点就是字符串*不可变*。这种不可变性是通过内部的`private final char[]`字段，以及没有任何修改`char[]`的方法实现的。
```java
public class Main{
public static void main(String[] args){
String s = "Hello!";
System.out.println(s);
s = s.toUpperCase();
System.out.println(s);
}
}
```
# 方法
## 字符串比较
当我们想要比较两个字符串是否相同时，要特别注意，我们实际上是想比较字符串的内容是否相同。必须使用`equals()`方法而不能用`==`。
```java
public class Main{
public static void main(String[] args){
String s1 = "hello";
String s2 = "hello";
System.out.println(s1==s2);
System.out.println(s1.equals(s2));
}
}
```
从表面上看，两个字符串用`==`和`equals()`比较都为`true`，但实际上那只是Java编译器在编译期，会自动把所有相同的字符串当作一个对象放入常量池，自然`s1`和`s2`的引用就是相同的。所以，这种`==`比较返回`true`纯属巧合。换一种写法，`==`比较就会失败。
结论：两个字符串比较，必须总是使用`equals()`方法。
要忽略大小写比较，使用`equalsIgnoreCase()`方法。
## 搜索字串、提取字串
```java
//是否包含子串
"Hello".contains("lo"); //true
"Hello".indexOf("l"); //2
"Hello".lastIndexOf("l"); //3
"Hello".startsWith("He"); //true
"Hello".endsWith("lo"); //true
"Hello".substring(2); //"llo"
"Hello".substring(2, 4); //"ll"
```
## 去除首尾空白字符
```java
" \tHello\r\n".trim(); //"Hello"
//注意：trim()并没有改变字符串的内容，而是返回了一个新字符串。
```
## 替换子串
```java
//根据字符或字符串替换
String s = "hello";
s.replace('l', 'w'); //"hewwo"，所有字符'l'被替换为'w'
//通过正则表达式替换
String s = "A,,B;C ,D";
s.replaceAll("[\\,\\;\\s]+", ","); //"A,B,C,D"
```
## 分割字符串
```java
String s = "A,B,C,D";
String[] ss = s.split("\\,"); // {"A", "B", "C", "D"}
```
## 拼接字符串
```java
String[] arr = {"A", "B", "C"};
String s = String.join("***", arr); // "A***B***C"
```
### 格式化字符串
```java
public class Main {
public static void main(String[] args) {
String s = "Hi %s, your score is %d!";
System.out.println(s.formatted("Alice", 80));
System.out.println(String.format("Hi %s, your score is %.2f!", "Bob", 59.5));
}
}
//有几个占位符，后面就传入几个参数。参数类型要和占位符一致。我们经常用这个方法来格式化信息。
```
### 类型转换
要把任意基本类型或引用类型转换为字符串，可以使用静态方法`valueOf()`。这是一个重载方法，编译器会根据参数自动选择合适的方法。
```java
String.valueOf(123); // "123"
String.valueOf(45.67); // "45.67"
String.valueOf(true); // "true"
String.valueOf(new Object()); // 类似java.lang.Object@636be97c
```
要把字符串转换为其他类型，就需要根据情况。例如，把字符串转换为`int`类型
```java
int n1 = Integer.parseInt("123"); // 123
int n2 = Integer.parseInt("ff", 16); // 按十六进制转换，255
```
把字符串转换为`boolean`类型
```java
boolean b1 = Boolean.parseBoolean("true"); // true
boolean b2 = Boolean.parseBoolean("FALSE"); // false
```
要特别注意，`Integer`有个`getInteger(String)`方法，它不是将字符串转换为`int`，而是把该字符串对应的系统变量转换为`Integer`
```java
Integer.getInteger("java.version"); // 版本号，11
```
### 转换为char[]
`String`和`char[]`类型可以互相转换，方法是
```java
char[] cs = "Hello".toCharArray(); // String -> char[]
String s = new String(cs); // char[] -> String
```
如果修改了`char[]`数组，`String`并不会改变
```java
public class Main {
public static void main(String[] args) {
char[] cs = "Hello".toCharArray();
String s = new String(cs);
System.out.println(s);
cs[0] = 'X';
System.out.println(s);
}
}
```
这是因为通过`new String(char[])`创建新的`String`实例时，它并不会直接引用传入的`char[]`数组，而是会复制一份，所以，修改外部的`char[]`数组不会影响`String`实例内部的`char[]`数组，因为这是两个不同的数组。
从`String`的不变性设计可以看出，如果传入的对象有可能改变，我们需要复制而不是直接引用。