前言
大家好，今天给大家分享java基础知识之String。
String类的重要性就不必说了，可以说是我们后端开发用的最多的类，所以，很有必要好好来聊聊它。
本文主要内容如下：
String简介
我们先来说说，java中八大数据类型，然后在说String。
八大基本数据类型
byte：8位，最大存储数据量是255，存放的数据范围是-128~127之间。
short：16位，最大数据存储量是65536，数据范围是-32768~32767之间。
int：32位，最大数据存储容量是2的32次方减1，数据范围是负的2的31次方到正的2的31次方减1。
long：64位，最大数据存储容量是2的64次方减1，数据范围为负的2的63次方到正的2的63次方减1。
float：32位，数据范围在3.4e-45~1.4e38，直接赋值时必须在数字后加上f或F。
double：64位，数据范围在4.9e-324~1.8e308，赋值时可以加d或D也可以不加。
boolean：只有true和false两个取值。
char：16位，存储Unicode码，用单引号赋值。
除了这八大数据类型以外(八大数据类型也有与之对应的封装类型，我相信你是知道的)，Java中还有一种比较特殊的类型：String，字面意义就是字符串。
String官方介绍
英文版
地址：https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html
看不懂吗？没事，我们可以借用翻译工具，浏览器自带的，更希望的是你能看懂原版英文。
String 存在于咱们安装的JDK目录下rt.ar包中，全路径名为：java.lang.String。我们java代码中String用来表示字符串，比如：
String str = "中国梦，我的梦";
String name = "zhangsan";
登录后复制
暂时先知道这些就可以了。
String使用
定义类型
在日常开发中，使用String的地方太多了，尤其是用来定义变量、常量的类型，基本上只要你码代码，总是能见到它。
比如：用户信息,用实体类User来表示。
public class User{
private Long id;
private String userName;
private String address;
private String password;
....
}
登录后复制
常用方法演示
String类有20多个方法，下面给出一个使用示例（这里演示大部分方法，剩下的可以自行去试试）。
//案例代码，来源于网络
public class StringDemo {
public static void main(String[] args) throws Exception {
String str1 = "Hello World";
String str2 = "Hello World";
String str3 = "hello world";
String str4 = " hello world ";
//返回字符串的长度
System.out.println("r1: " + str1.length());
//比较两个字符串的大小compareTo(返回的是int),0相等，复数小于，正数大于
System.out.println("r2 : " + str1.compareTo(str2));
//比较两个字符串的大小compareTo(返回的是int),0相等，复数小于，正数大于
System.out.println("r3 : " + str1.compareTo(str3));
//字符串比较compareToIgnoreCase，忽略大小写。0相等，复数小于，正数大于
System.out.println("r4 : " + str1.compareToIgnoreCase(str3));
//字符串查找indexOf，返回的是找到的第一个的位置，没找到返回-1。从0开始
System.out.println("r5 : " + str1.indexOf("o"));
//查找字符串最后一次出现的位置lastIndexOf
System.out.println("r6 : " + str1.lastIndexOf("o"));
//删除字符串中的一个字符,字符串从0开始的 substring(a, b)
//返回指定起始位置（含）到结束位置（不含）之间的字符串
System.out.println("r7 : " + str1.substring(0, 5) + str1.substring(6));
//字符串替换,替换所有
System.out.println("r8 : " + str1.replace("o", "h"));
//字符串替换,替换所有
System.out.println("r9 : " + str1.replaceAll("o", "h"));
//字符串替换,替换第一个
System.out.println("r10 : " + str1.replaceFirst("o", "h"));
//字符串反转
System.out.println("r11 : " + new StringBuffer(str1).reverse());
//字符串反转
System.out.println("r11’: " + new StringBuilder(str1).reverse());
//字符串分割
String[] temp = str1.split("\ ");
for (String str : temp) {
System.out.println("r12 : " + str);
}
//字符串转大写
System.out.println("r13 : " + str1.toUpperCase());
//字符串转小写
System.out.println("r14 : " + str1.toLowerCase());
//去掉首尾空格
System.out.println("r15 : " + str4.trim());
//是否包含,大小写区分
System.out.println("r16 : " + str1.contains("World"));
//返回指定位置字符
System.out.println("r17 : " + str1.charAt(4));
//测试此字符串是否以指定的后缀结束
System.out.println("r18 : " + str1.endsWith("d"));
//测试此字符串是否以指定的前缀开始
System.out.println("r19 : " + str1.startsWith("H"));
//测试此字符串从指定索引开始的子字符串是否以指定前缀开始
System.out.println("r20 : " + str1.startsWith("ll", 2));
//将指定字符串连接到此字符串的结尾。等价于用“+”
System.out.println("r21 : " + str1.concat("haha"));
//比较字符串的内容是否相同
System.out.println("r22 : " + str1.equals(str2));
//与equals方法类似，忽略大小写
System.out.println("r23 : " + str1.equalsIgnoreCase(str2));
//判断是否是空字符串
System.out.println("r24: " + str1.isEmpty());
}
}
登录后复制
我们开发中差不多也就是这么使用了，但是如果你仅仅是使用很牛了，貌似遇到面试照样会挂。所以，学知识，不能停留在使用层面，需要更深层次的学习。
下面我们就来深层次的学习String，希望大家带着一颗平常的心学习，不要害怕什么，灯笼是张纸，捅破不值钱。
String核心部分源码分析
备注：JDK版本为1.8+，因为JDK9版本中和旧版本有细微差别。
String类源码注释
/**
* The {@code String} class represents character strings. All
* string literals in Java programs, such as {@code "abc"}, are
* implemented as instances of this class.
* 这个String类代表字符串。java编程中的所有字符串常量。
* 比如说："abc"就是这个String类的实例
*
* Strings are constant; their values cannot be changed after they
* are created.
* 字符串是常量，他们一旦被创建后，他们的值是不能被修改。（重点）
* String buffers support mutable strings.
* String缓存池支持可变的字符串，
* Because String objects are immutable they can be shared. For example:
* 因为String字符串不可变，但他们可以被共享。比如：
*
* String str = "abc";
*
* is equivalent to:
*
* char data[] = {'a', 'b', 'c'};
* String str = new String(data);
*
* Here are some more examples of how strings can be used:
* String使用案例
* System.out.println("abc");
* String cde = "cde";
* System.out.println("abc" + cde);
* String c = "abc".substring(2,3);
* String d = cde.substring(1, 2);
*
* The class {@code String} includes methods for examining
* individual characters of the sequence, for comparing strings, for
* searching strings, for extracting substrings, and for creating a
* copy of a string with all characters translated to uppercase or to
* lowercase. Case mapping is based on the Unicode Standard version
* specified by the {@link java.lang.Character Character} class.
* 这个String类包含了一些测评单个字符序列的方法，比如字符串比较，查找字符串，
* 提取字符串，和拷贝一个字符串的大小写副本。
* 大小写映射的是基于Character类支持的Unicode的字符集标准版本。
*
* The Java language provides special support for the string
* concatenation operator ( + ), and for conversion of
* other objects to strings.
* java语言提供了对字符串的特殊支持，如：可以通过"+"号来进行字符串的拼接操作，
* 为其他类提供了与字符串转换的操作
* String concatenation is implemented
* through the {@code StringBuilder}(or {@code StringBuffer})
* class and its {@code append} method.
* 字符串的+号拼接操作是通过StringBuilder或者StringBuffer类的append()方法
* 来实现的
* String conversions are implemented through the method
* {@code toString}, defined by {@code Object} and
* inherited by all classes in Java.
* 对象与字符串的转换操作是通过所有类的父类Object中定义的toString()方法来实现的
* For additional information on
* string concatenation and conversion, see Gosling, Joy, and Steele,
* The Java Language Specification.
*
*
Unless otherwise noted, passing a null argument to a constructor
* or method in this class will cause a {@link NullPointerException} to be
* thrown.
* 除非有特殊说明，否则传一个null给String的构造方法或者put方法，会报空指针异常的
*
A {@code String} represents a string in the UTF-16 format
* in which supplementary characters are represented by surrogate
* pairs (see the section Unicode
* Character Representations in the {@code Character} class for
* more information).
* 一个String 对象代表了一个UTF-16编码语法组成的字符串
* Index values refer to {@code char} code units, so a supplementary
* character uses two positions in a {@code String}.
*
The {@code String} class provides methods for dealing with
* Unicode code points (i.e., characters), in addition to those for
* dealing with Unicode code units (i.e., {@code char} values).
* 索引值指向字符码单元，所以一个字符在一个字符串中使用两个位置，
* String 类提供了一些方法区处理单个Unicode编码，除了那些处理Unicode代码单元。
* @since JDK1.0
*/
登录后复制
以上便是String类注释的整个片段，后面剩下的就是作者、相关类、相关方法以及从JDK哪个版本开始有的。
String类定义
public final class String
implements java.io.Serializable, Comparable, CharSequence {
....
}
登录后复制
类图
String类被final修饰，表示String不可以被继承。下面我们来说说String实现三个接口有什么用处：
- 实现Serializable，可以被序列化
- 实现Comparable，可以用于比较大小（按顺序比较单个字符的ASCII码）
- 实现CharSequence，表示是一个有序字符的序列，（因为String的本质是一个char类型数组）
简单介绍final
修饰类：类不可被继承，也就是说，String类不可被继承了
修饰方法：把方法锁定，以访任何继承类修改它的涵义
修饰遍历：初始化后不可更改
重要成员
/** The value is used for character storage. */
// 来用存储String内容的
private final char value[];
// 存储字符串哈希值，默认值为0
private int hash; // Default to 0
// 实现序列化的标识
private static final long serialVersionUID = -6849794470754667710L;
登录后复制
char value[]被final修饰，说明value[]数组是不可变的。
构造方法
/**
* Initializes a newly created {@code String} object so that it represents
* an empty character sequence. Note that use of this constructor is
* unnecessary since Strings are immutable.
* 初始化新创建的String对象，时期表示空字符串序列。
* 注意：这个构造方法的用法是没必要的，因为字符串是不可变的
*/
public String() {
this.value = "".value;
}
登录后复制
无参构造方法中是将一个空字符串的value值赋给当前value。
/**
* Initializes a newly created {@code String} object so that it represents
* the same sequence of characters as the argument; in other words, the
* newly created string is a copy of the argument string. Unless an
* explicit copy of {@code original} is needed, use of this constructor is
* unnecessary since Strings are immutable.
* 初始化创建的String对象，时期表示与参数相同的字符串序列。
* 换句话说：新创建的字符串是参数自粗糙的副本。
* 除非，如果需要original的显示副本，否则也是没有必要使用此构造方法的
* 因为字符串是不可变的
* @param original
* A {@code String}
*/
public String(String original) {
this.value = original.value;
this.hash = original.hash;
}
//案例: String str=new String("abc");
登录后复制
把original的value赋给当前的value，并把original的hash赋给当前的hash。
/**
* Allocates a new {@code String} so that it represents the sequence of
* characters currently contained in the character array argument. The
* contents of the character array are copied; subsequent modification of
* the character array does not affect the newly created string.
* 分配一个新的{@code String}，以便它表示字符数组参数中当前包含的字符。这个
* 复制字符数组的内容；随后修改字符数组不影响新创建的字符串。
* @param value
* The initial value of the string
*/
public String(char value[]) {
//注:将传过来的char数组copy到value数组里
this.value = Arrays.copyOf(value, value.length);
}
//Arrays类中的copyOf方法
public static char[] copyOf(char[] original, int newLength) {
//创建一个新的char数组
char[] copy = new char[newLength];
//把original数组中内容拷贝到新建的char数组中
System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength));
//返回新建的char数组
return copy;
}
登录后复制
使用Arrays类的copyOf方法，新建一个char数组，将original的内容放到新建的char数组中。
然后，把新建的char数组赋给当前的vlaue。
public String(StringBuffer buffer) {
synchronized(buffer) {
this.value = Arrays.copyOf(buffer.getValue(), buffer.length());
}
}
登录后复制
因为StringBuffer是线程安全类，所以，这里加了同步锁，保证线程安全。
public String(StringBuilder builder) {
this.value = Arrays.copyOf(builder.getValue(), builder.length());
}
登录后复制
StringBuilder是非线程安全的，这里也就没有做线程安全处理，其他内容和前面一样。
注：很多时候我们不会这么去构造,因为StringBuilder跟StringBuffer有toString方法如果不考虑线程安全,优先选择StringBuilder
这里就讲这么多构造方法，其他很复杂，也基本不用，所以，了解这些就够了。如果对其他感兴趣的，可以自行去研究研究。
常用方法分析
前面的使用案例中，我们已经对String的大部分方法进行演示一波，这里我们就挑几个相对重要的方法进行深度解析。
hashCode方法
hashCode()方法是在Object类中定义的，String对其进行了重写。
public int hashCode() {
int h = hash;
if (h == 0 && value.length > 0) {
char val[] = value;
//hash算法，s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]
//使用{@codeint}算法，其中{@codes[i]}是 i字符串的第个字符，
//{@code n}是字符串，{@code^}表示指数运算。
for (int i = 0; i < value.length; i++) {
h = 31 * h + val[i];
}
hash = h;
}
return h;
}
登录后复制
hashCode的一个具体实现，由于java体系中每个对象都可以转换成String，因此他们应该都是通过这个hash来实现的
接着，我们看看equals()方法；
equals()方法
equals()方法也是Object类中定义的，String类对其进行了重写。
public boolean equals(Object anObject) {
//首先会判断是否是同一个对象
if (this == anObject) {
return true;
}
//判断是否为String类型
if (anObject instanceof String) {
String anotherString = (String)anObject;
int n = value.length;
//长度是否相同
if (n == anotherString.value.length) {
char v1[] = value;
char v2[] = anotherString.value;
int i = 0;
//逐个遍历判断是否相等
//从后往前单个字符判断，如果有不相等，返回假
while (n-- != 0) {
//不相等，直接返回false
if (v1[i] != v2[i])
return false;
i++;
}
return true;
}
}
return false;
}
登录后复制
补充：==比较
==比较基本数据类型，比较的是值
==比较引用数据类型，比较的是地址值
登录后复制
substring()方法
substring方法在工作使用的也是相当的多，作用就是截取一段字符串。
public String substring(int beginIndex) {
if (beginIndex < 0) {
throw new StringIndexOutOfBoundsException(beginIndex);
}
int subLen = value.length - beginIndex;
if (subLen < 0) {
throw new StringIndexOutOfBoundsException(subLen);
}
//如果beginIndex==0，返回的是当前对象，
//否则这里是new的一个新对象，其实String中的很多函数都是这样的操作
return (beginIndex == 0) ? this : new String(value, beginIndex, subLen);
}
登录后复制
intern()方法
intern()方法是native修饰的方法，表示该方法为本地方法。
/*
* When the intern method is invoked, if the pool already contains a
* string equal to this {@code String} object as determined by
* the {@link #equals(Object)} method, then the string from the pool is
* returned. Otherwise, this {@code String} object is added to the
* pool and a reference to this {@code String} object is returned.
*/
public native String intern();
登录后复制
方法注释会有写到，意思就是调用方法时，如果常量池有当前String的值，就返回这个值，没有就加进去，返回这个值的引用。
案例如下
public class StringDemo {
public static void main(String[] args) throws Exception {
String str1 = "a";
String str2 = "b";
String str3 = "ab";
String str4 = str1 + str2;
String str5 = new String("ab");
System.out.println(str5 == str3);//堆内存比较字符串池
//intern如果常量池有当前String的值,就返回这个值,没有就加进去,返回这个值的引用
System.out.println(str5.intern() == str3);//引用的是同一个字符串池里的
System.out.println(str5.intern() == str4);//变量相加给一个新值，所以str4引用的是个新的
System.out.println(str4 == str3);//变量相加给一个新值，所以str4引用的是个新的
}
}
登录后复制
运行结果
false
true
false
false
登录后复制
length()方法
获取字符串长度，实际上是获取字符数组长度 ，源码就非常简单了，没什么好说的。
public int length() {
return value.length;
}
登录后复制
isEmpty() 方法
判断字符串是否为空，实际上是盼复字符数组长度是否为0 ，源码也是非常简单，没什么好说的。
public boolean isEmpty() {
return value.length == 0;
}
登录后复制
charAt(int index) 方法
根据索引参数获取字符 。
public char charAt(int index) {
//索引小于0或者索引大于字符数组长度，则抛出越界异常
if ((index = value.length)) {
throw new StringIndexOutOfBoundsException(index);
}
//返回字符数组指定位置字符
return value[index];
}
登录后复制
getBytes()方法
获取字符串的字节数组，按照系统默认字符编码将字符串解码为字节数组 。
public byte[] getBytes() {
return StringCoding.encode(value, 0, value.length);
}
登录后复制
compareTo()方法
这个方法写的很巧妙，先从0开始判断字符大小。如果两个对象能比较字符的地方比较完了还相等，就直接返回自身长度减被比较对象长度，如果两个字符串长度相等，则返回的是0，巧妙地判断了三种情况。
public int compareTo(String anotherString) {
//自身对象字符串长度len1
int len1 = value.length;
//被比较对象字符串长度len2
int len2 = anotherString.value.length;
//取两个字符串长度的最小值lim
int lim = Math.min(len1, len2);
char v1[] = value;
char v2[] = anotherString.value;
int k = 0;
//从value的第一个字符开始到最小长度lim处为止，如果字符不相等，
//返回自身（对象不相等处字符-被比较对象不相等字符）
while (k < lim) {
char c1 = v1[k];
char c2 = v2[k];
if (c1 != c2) {
return c1 - c2;
}
k++;
}
//如果前面都相等，则返回（自身长度-被比较对象长度）
return len1 - len2;
}
登录后复制
startsWith()方法
public boolean startsWith(String prefix, int toffset) {
char ta[] = value;
int to = toffset;
char pa[] = prefix.value;
int po = 0;
int pc = prefix.value.length;
// Note: toffset might be near -1>>>1.
//如果起始地址小于0或者（起始地址+所比较对象长度）大于自身对象长度，返回假
if ((toffset value.length - pc)) {
return false;
}
//从所比较对象的末尾开始比较
while (--pc >= 0) {
if (ta[to++] != pa[po++]) {
return false;
}
}
return true;
}
public boolean startsWith(String prefix) {
return startsWith(prefix, 0);
}
public boolean endsWith(String suffix) {
return startsWith(suffix, value.length - suffix.value.length);
}
登录后复制
起始比较和末尾比较都是比较经常用得到的方法，例如：在判断一个字符串是不是http协议的，或者初步判断一个文件是不是mp3文件，都可以采用这个方法进行比较。
concat()方法
public String concat(String str) {
int otherLen = str.length();
//如果被添加的字符串为空，返回对象本身
if (otherLen == 0) {
return this;
}
int len = value.length;
char buf[] = Arrays.copyOf(value, len + otherLen);
str.getChars(buf, len);
return new String(buf, true);
}
登录后复制
concat方法也是经常用的方法之一，它先判断被添加字符串是否为空来决定要不要创建新的对象。
replace()方法
public String replace(char oldChar, char newChar) {
//新旧值先对比
if (oldChar != newChar) {
int len = value.length;
int i = -1;
char[] val = value;
//找到旧值最开始出现的位置
while (++i < len) {
if (val[i] == oldChar) {
break;
}
}
//从那个位置开始，直到末尾，用新值代替出现的旧值
if (i < len) {
char buf[] = new char[len];
for (int j = 0; j < i; j++) {
buf[j] = val[j];
}
while (i < len) {
char c = val[i];
buf[i] = (c == oldChar) ? newChar : c;
i++;
}
return new String(buf, true);
}
}
return this;
}
登录后复制
这个方法也有讨巧的地方，例如最开始先找出旧值出现的位置，这样节省了一部分对比的时间。replace(String oldStr,String newStr)方法通过正则表达式来判断。
trim()方法
public String trim() {
int len = value.length;
int st = 0;
char[] val = value; /* avoid getfield opcode */
//找到字符串前段没有空格的位置
while ((st < len) && (val[st]
