【Java SE】String类 庖丁解牛，深层剖析

为什么要包装String类

C语言中是怎么表示字符串的？ 通过字符数组或者是使用字符指针，对字符串的操作可以使用库函数提供的字符串系列函数完成，但是这种将数据和操作方法分开的方式不符合面向对象的思想，所以，Java提供了String类，对字符串和有关字符串的操作打包在一起。在开发，校招笔试，面试中，对字符串的考察是很常见的，所以，我们有必要好好研究下String类。

String类的属性

首先我们得明确一点，String是一个引用类型，它本身不存储数据，我们来看看String类的源码：

源码中我们看到字符串实际上也是存储在一个字符数组中的，还有一个int类型的hash。

hash叫字符串哈希值，其实就是将任意长度的字符串通过一套固定的运算方法转换为一串唯一的数值。如果两个字符串相同，哈希值也相同。

也就是说我们的一个String类对象包含两部分内容：

String类对象的构造方法

String提供的构造方法有很多，主流常用的有以下几种：

public static void main(String[] args) {
    //使用常量串构造
    String str1 = "hello";
    System.out.println(str1);
    //直接new对象，调用需要一个String类对象的构造方法
    String str2 = new String("hello");
    System.out.println(str2);
    //利用字符数组来构造
    char[] arr = {'h','e','l','l','o'};
    String str3 = new String(arr);
    System.out.println(str3);
}

1. 常量串构造

在Java中，我们把" "引起来的字符串叫做常量字符串，它也是一个String类的对象，而且，" "引起来的字符串会被放在字符串常量池，后面细说。

所以， String str1 = "hello";这段代码其实就是一个赋值操
作，把"hello"这个对象的地址交给str1，str1就引用了"hello"对象。"hello"对象是已经存在的，str1存储了它的地址，str1并没有在堆上开辟空间。

2. new关键字构造

使用new关键字调用构造方法构造时，最常用的就是以下两种构造方法：

第一种就是传入一个String类型的对象，然后注意看它的源码：

	public String(String original) {
	    this.value = original.value;
	    this.hash = original.hash;
	}

original.value就是传入字符串对象的字符数组的地址，第一条语句执行，让要实例化的字符串对象的value也指向original.value，第二条语句则是同样赋予相同的哈希值。

3. 字符数组构造

先来看看字符构造方法的源码：

这个方法只有一条语句，我们发现它是调用了Java提供的Arrays的copyOf方法，这个copyOf是专门来进行数组拷贝的，第一个参数是要拷贝的数组，第二个参数代表需要拷贝的长度（拷贝的元素个数，从0下标开始），这里传入value.length说明拷贝整个数组，拷贝完成返回数组的地址。

同样我们做示意图来理解：

String对象的比较

比较两个字符串是不是相等有几种方法呢？能不能直接用“==”呢？

==比较两个引用

看下这段代码，str1和str2会相等吗？ str1和str3会相等吗？str2和str4呢？

     public static void main(String[] args) {
        String str1 = "hello";
        String str2 = new String("hello");
        String str3 = str1;
        String str4 = new String("hello");

        System.out.println(str1 == str2);
        //不相等
        System.out.println(str1 == str3);
        //相等
        System.out.println(str2 == str4);
        //不相等
    }

运行结果：

这几个字符串不都是"hello"吗？ 怎么都不相等？ 这是因为“==”比较的是两个数据的值相等不相等，引用类型那就是比较两个对象的地址是否相同啦。

我们来分析一下不相等的原因：

可以看到只有str1和str3的地址相同，因为他们进行了赋值操作，而其他的几个引用都使用了new关键字，只要使用new关键字就一定会在堆上开辟内存空间，所以这几个对象肯定会有不同的内存地址。

compareTo方法比较两个对象

compareTo方法我们在抽象类和接口里也说过，详情请点击这里，同样要使用compareTo方法也需要实现Comparable接口：

String的compareTo方法：

它与equals不同，返回的是int类型，比较规则为：

1. 先按照字典次序大小比较，如果出现不等的字符，直接返回这两个字符的大小差值。
2. 如果前k个字符相等(k为两个字符长度最小值)，返回值两个字符串长度差值。

public static void main(String[] args) {
	String s1 = new String("abc");
	String s2 = new String("ac");
	String s3 = new String("abc");
	String s4 = new String("abcdef");
	System.out.println(s1.compareTo(s2)); // 不同输出字符差值-1(b-c)
	System.out.println(s1.compareTo(s3)); // 相同输出 0
	System.out.println(s1.compareTo(s4)); // 前k个字符完全相同，输出长度差值-3(3-6)
}

运行结果：

compareToIgnoreCase方法

比较规则与compareTo相同，只是它忽略了字符大小写，比如’A’ 和 ‘a’ 认为是相同的字符。如图所示：

equals方法比较两个对象

在之前接口部分我们说Object类中存在一个equals方法，它是直接比较两个对象的地址是否相同（详情请点击）而要比较两个对象的属性是否相同就需要在该类中重写equals方法，String中就重写了这个方法。

现在我们用equals来测试上面的代码：

    public static void main(String[] args) {
        String str1 = "hello";
        String str2 = new String("hello");
        String str3 = str1;
        String str4 = new String("hello");

        System.out.println(str1.equals(str2));
        System.out.println(str1.equals(str3));
        System.out.println(str2.equals(str4));
    }

运行结果：

这样使用equals，这几个字符串就全都相等了。

str1和str2虽然地址不同，但是字符串相同，同理str2和str4也是地址不同字符串相同，而str1和str3则是地址相同直接返回true。

String类的常用方法

字符串查找

方法	功能
char charAt(int index)	返回index位置上字符，如果index为负数或者越界，抛出IndexOutOfBoundsException异常
int indexOf(int ch)	返回ch第一次出现的位置，没有返回-1
int indexOf(int ch, int fromIndex)	从fromIndex位置开始找ch第一次出现的位置，没有返回-1
int indexOf(String str)	返回str第一次出现的位置，没有返回-1
int indexOf(String str, int fromIndex)	从fromIndex位置开始找str第一次出现的位置，没有返回-1
int lastIndexOf(int ch)	从后往前找，返回ch第一次出现的位置，没有返回-1
int lastIndexOf(int ch, int fromIndex)	从fromIndex位置开始找，从后往前找ch第一次出现的位置，没有返回-1
int lastIndexOf(String str)	从后往前找，返回str第一次出现的位置，没有返回-1
int lastIndexOf(String str, int fromIndex)	从fromIndex位置开始找，从后往前找str第一次出现的位置，没有返回-1

字符串转换

数字转为字符串

将一个数字转为字符串需要用到的是String.valueOf()方法，它可以接受int，long，double，float，boolean，char类型的数据，甚至一个字符数组，一个引用类型也可以，并将他们转为字符串返回，我们来看看源码：

我们发现基本数据类型都是调用了各自包装类的toString()方法，那这样的话，我们也可以不用String.valueOf()方法，直接使用各自的toString方法也能达到相同的效果。

不过，要是使用toString方法的话，就需要清楚的知道数据各自的包装类是什么，所以，使用String.valueOf更方便，编译器自动帮我们识别。

大小写转换

将字符串中的小写字母转换为大写用toUpperCase()
将字符串中的大写字母转换为小写用toLowerCase()

public static void main(String[] args) {
	String s1 = "hello";
	String s2 = "HELLO";
	// 小写转大写
	System.out.println(s1.toUpperCase());
	// 大写转小写
	System.out.println(s2.toLowerCase());
}

字符串转数组

    public static void main(String[] args) {
        String s = "hello";
        // 字符串转数组
        char[] ch = s.toCharArray();
        for (int i = 0; i < ch.length; i++) {
            System.out.print(ch[i] + " ");
        }
    }

格式化返回字符串

    public static void main(String[] args) {
        String str = String.format("%d.%d.%d", 2022, 5, 3);
        System.out.println(str);
    }

字符串替换

就是用一个指定的新的字符串替换掉已有的字符串数据。

方法	功能
String replace(char oldChar, char newChar)	用newchar替换掉字符串中所有oldchar
String replaceAll(String regex, String replacement)	替换所有的指定内容
String replaceFirst(String regex, String replacement)	替换首个出现的指定字符串

字符串拆分

将一个完整的字符串按照指定的分隔符划分为若干个子字符串。我们需要用到split()方法。

方法	功能
String[] split(String regex)	按照分隔符全部拆分
String[] split(String regex, int limit)	按照分隔符拆分limit组

    public static void main(String[] args) {
        String str = "hello#world#hello csdn";
        String[] strs1 = str.split("#");
        for(String s : strs1) {
            System.out.println(s);
        }
    }

拆分limit组：

    public static void main(String[] args) {
        String str = "hello#world#hello csdn";
        String[] strs1 = str.split("#", 2);
        for(String s : strs1) {
            System.out.println(s);
        }
    }

若有多个分隔符，比如遇到"#" 和" "空格都会分割，就可以用|分隔开来。

    public static void main(String[] args) {
        String str = "hello#world#hello csdn";
        String[] strs1 = str.split("#| ");
        for(String s : strs1) {
            System.out.println(s);
        }
    }

1. 字符"|","*","+"都得加上转义字符，前面加上 "\\" .
2. 而如果是"\"，那么就得写成 "\\\\" .
3. 如果一个字符串中有多个分隔符，可以用"|"作为连字符.

字符串截取

在一个字符串中截取一部分子字符串。

方法	功能
String substring(int beginIndex)	从指定索引截取到结尾
String substring(int beginIndex, int endIndex)	截取从指定下标范围的子字符串，范围左闭右开

    public static void main(String[] args) {
        String str = "helloworld";
        System.out.println(str.substring(5));
        System.out.println(str.substring(2,8));
    }

去掉字符串中左右两边的空格

使用方法String trim()

字符串常量池

字符串常量池介绍

我们在前面说过，" "引起来的字符串都会被放在常量池

那为什么会有常量池存在呢？ 我直接new对象也可以满足各种需求呀。

在Java中，“池”是一种常见的提高效率的方式。对于这种频繁使用的字符串，我们把他放在字符串常量池中，这样的话这个字符串对象只会在内存中存储一次，节省空间，且在new对象时，不用重新开辟空间，只需要在常量池中找到该字符串对象的地址，进行地址的赋值就可以了。

public static void main(String[] args) {
	String str1 = "hello";
	String str2 = "hello";
	System.out.println(s1 == s2); // true
}

字符串常量池在JVM中其实是StringTable类，实际是一个固定大小的HashTable(一种高效用来进行查找的数据结构，后序给大家详细介绍)，不同JDK版本下字符串常量池的位置以及默认大小是不同的，在JDK8中，大小可以设置，最小是1009。

intern方法

intern 是一个native方法(Native方法指：底层使用C++实现的，看不到其实现的源代码)，该方法的作用是手动将创建的String对象添加到常量池中。

因为" "引起来的字符串会被放在常量池，而字符数组不会，所以我们来试试把一个字符数组放在常量池。

没有放进常量池时：

    public static void main(String[] args) {
        char[] arr = {'h', 'e', 'l', 'l', 'o'};
        String str1 = new String(arr);
        String str2 = "hello";
        System.out.println(str1 == str2);
    }

放进常量池：

	public static void main(String[] args) {
	    char[] arr = {'h', 'e', 'l', 'l', 'o'};
	    String str1 = new String(arr);
	    str1.intern();
	    String str2 = "hello";
	    System.out.println(str1 == str2);
	}

字符串的不可变性

String是一种不可变对象. 字符串中的内容是不可改变。

通过源码我们发现，String类是被final修饰的。

在Java中被final修饰表示不能被继承，被final修饰的引用变量不能引用其他的对象。而该引用中的内容是可以被修改的。

而String的不可修改性体现在类和char[] value同时被final修饰。

首先String被final修饰表明这个对象只能引用当前对象，不能引用其他对象；其次，char[] value 是被private修饰的，且String中并未提供任何set方法对value进行修改，char[] value也被final修饰，value也不能指向其他的字符数组，从而奠定了字符串不能被修改的基础。

总结一下就是：

1. String类不能引用其他对象，只能引用当前对象。
2. String中的value是私有的，不能被修改且没有提供修改的方法。
3. String中的value被final修饰，不能指向其他数组。

而上面我们说过的String中所有有关字符串的修改，都会返回一个新的字符串，并没有对字符串本身进行修改。

字符串用"+="拼接

我们在Java中经常使用到"+="来对字符串进行拼接然后输出，比如重写的toString方法，来看看+=到底是怎么执行的。

    public static void main(String[] args) {
        String str = "hello";
        str += "world";
        System.out.println(str);
    }

对这一段代码，我们看看它的字节码。

我们来数一数，光是拼接一次字符串，我们就创建了多少个对象：

1. 创建String类 “hello”
2. 创建可修改本身字符串的StringBuilder类对象，对字符串进行拼接。
3. 调用StringBuilder的toString方法，该方法也会new一个新的String对象出来，把地址返回给str。
   
   所以，我们是不建议这么使用的，因为这个过程中，创建了许多临时对象，效率太低了。

那怎么高效做到对字符串的修改呢？答案是借助StringBuffer 和 StringBuilder。

---

StringBuilder和StringBuffer

StringBuilder的介绍及使用

因为String不可修改，为了方便字符串的修改，Java提供了StringBuilder和StringBuffer类，他们可以对字符串进行修改，因为这两个类大部分功能相同，我们只介绍一下StringBuilder类的一些常用方法。

通过源码我们发现，StringBuilder是继承了一个AbstractStringBuilder类的，那我们来看看它的父类。

看到了吗？父类中存在一个没有修饰符的char[] value， 这也是为什么StringBuilder存的字符串可以被修改的原因。

以下是一些常用方法，供大家参考：

方法	功能
StringBuff append(String str)	在尾部追加，相当于String的+=，可以追加：boolean、char、char[]、double、float、int、long、Object、String、StringBuff的变量
char charAt(int index)	获取index位置的字符
int capacity()	获取底层保存字符串空间总的大小
void ensureCapacity(int mininmumCapacity)	扩容
void setCharAt(int index, char ch)	将index位置的字符设置为ch
int indexOf(String str)	返回str第一次出现的位置
StringBuff insert(int offset, String str)	在offset位置插入：八种基类类型 & String类型 & Object类型数据
StringBuffer deleteCharAt(int index)	删除index位置的字符
StringBuffer delete(int start, int end)	删除[start, end)区间内的字符
StringBuffer replace(int start, int end, String str)	将[start, end)位置的字符替换为str
StringBuffer reverse()	反转字符串
String toString()	把所有字符串返回为String类型

Stringh和StringBuilder之间的相互转换

1. StringBulider转换为String类型，使用StringBuilder的toString方法。
2. String类型转换为StringBuilder类型，使用StringBulider的构造方法StringBuilder(String str)。

---

码字不易，点个赞再走吧，收藏不迷路~