Java从入门到干活必须要懂的String类，看这一篇足矣

欢迎关注微信公众号：Coding我不配  
获取更多干货，一起每天进步一点点

1 初识 String 类

小伙伴们几乎都是从第一个 HelloWorld 程序:

package com.coding.wbp
public class HelloWorld {
  // Java 入口程序，程序从此开始执行
  public static void main(String[] args) {
    String content = "Hello,World!"
    System.out.println(content); // 向控制台打印一条语句
  }
}

开始接触 String 类，估计那个时候它认识你，而你不认识它。String 类是 java 编程中使用频率最高的类，没有之一，而且在面试中几乎都以 String 相关问题开始的，深入掌握 String 的知识是必要的。

2 String 类如何定义

Java API 中这样描述：

The {@code String} class represents character strings. All
string literals in Java programs, such as {@code "abc"}, are
implemented as instances of this class.
Strings are constant; their values cannot be changed after they
are created...

即 String 类表示字符串。Java 程序中的所有字符串（如 “abc” ）都作为此类实现的实例。字符串是常量；它们的值在创建之后不能更改。

以当下主流的 JDK 版本 1.8 为例，String 类内部存储结构为字符数组，源码如下：

package java.lang;//源码包路径,这个包下面定义java基本类型
public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[];//决定String类不可变

    /** Cache the hash code for the string */
    private int hash; // Default to 0
    // ... other
}

String 类被定义为 final 类型，即不可被其他类继承。从成员变量 final char 数组知道 String 类存储的值是 final 类型的，不能被改变的，所以 string 中存储的某个改变就会生成一个新的 String 类型对象，存储 String 数据也不一定从数组的第 0 个元素开始的，而是从 offset 所指的元素开始。

在 JDK 1.9 之后 String 类的实现改用 byte 数组来存储字符串
private final byte[] value

JDK1.8 中 String 源代码中包含几个重要的方法：

2.1 构造方法

String 类有以下 4 个重要的构造方法：

//无参构造方法
public String() {
   this.value = "".value;
}
// String 为参数的构造方法，这个最为常用
public String(String original) {
    this.value = original.value;
    this.hash = original.hash;
}
// char[] 为参数构造方法
public String(char value[]) {
    this.value = Arrays.copyOf(value, value.length);
}
// StringBuilder 为参数的构造方法
public String(StringBuilder builder) {
    this.value = Arrays.copyOf(builder.getValue(), builder.length());
}

其中，比较容易忽略的是以 StringBuilder 为参数的构造函数，这里涉及到 String，StringBuilder 和 StringBuffer 三者的区别相关知识，见下文。

2.2 equals 方法

String 类中的 equals 方法重写了 Object 中的 equals 方法，equals 方法需要传递一个 Object 类型的参数值，在比较时会先通过 instanceof 判断是否为 String 类型，如果不是则会直接返回 false，如果是，再比较字符串的长度及值是否相同。源码如下：

    //比较两个字符串是否相等
    public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) { //判断类型是否为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) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

2.3 其他经常用到的方法

• join()：把字符串数组转为字符串
• compareTo(): 比较两个字符串是否相等
• indexOf()：查询字符串首次出现的下标位置
• contains()：查询字符串中是否包含另一个字符串
• length()：查询字符串的长度
• replace()：替换字符串中的某些字符
• split()：把字符串分割并返回字符串数组

3 String 对象创建及使用

直接撸一把代码：

package com.coding.wbp
public static void main(String[] args) {
      String str1 = "abc";
      //方式1 直接赋值创建
      String str2 = "abc";
      //方式2 通过构造函数创建
      String str3 = new String("abc");
      System.out.println("str1 == str2 is " + (str1 == str2));
      System.out.println("str1 == str3 is " + (str1 == str3));
      System.out.println("str1.equals(str2) is " + str1.equals(str2));
      System.out.println("str2.equals(str3) is " + str2.equals(str3));
}

运行结果输出：

str1 == str2 is true
str1 == str3 is false
str1.equals(str2) is true
str2.equals(str3) is true

直接赋值和通过构造器创建两种方法的区别：

String str2 = “abc”;
此方式最多创建一个 String 对象，最少不创建 String 对象。如果常量池中,存在”abc”,那么 str2 直接引用，此时不创建 String 对象。否则，先在常量池先创建”abc”内存空间，再引用。

String str3 = new String(“abc”);
此方式最多创建两个 String 对象，至少创建一个 String 对象。因为 new 关键字一定会在堆空间开辟一块新的内存空间，而"abc"如果存在，则不创建，所以至少创建一个 String 对象。

4 String 常见面试题

4.1 String 定义为 final 类的好处

final 修饰的第一个好处是安全；第二个好处是高效。

• Java 语言之父 James Gosling 设计的初衷，他会更倾向于使用 final，因为它能够缓存结果，当你在传参时不需要考虑谁会修改它的值；如果是可变类的话，则有可能需要重新拷贝出来一个新值进行传参，这样在性能上就会有一定的损失。
• James Gosling 设计为 final 类的另一个原因是安全，当你在调用其他方法时，比如调用一些系统级操作指令之前，可能会有一系列校验，如果是可变类的话，可能在你校验过后，它的内部的值又被改变了，这样有可能会引起严重的系统崩溃问题。

若 String 允许被继承, 由于它的高度被使用率, 可能会降低程序的性能，所以 String 被定义成 final。另外如果指定一个类为 final，则该类所有的方法都是 final，Java 编译器会寻找机会内联（inline）所有的 final 方法（这和具体的编译器实现有关）。此举能够使性能平均提高 50%。

4.2 String、StringBuilder 和 StringBuffer 的区别

因为 String 类型是不可变的，所以在字符串拼接的时候如果使用 String 的话性能会很低，因此 JDK 提供了可变的两种数据类型 StringBuilder 及 StringBuffer。

1. 可变性

• String 类型的对象是 immutable 不可变的，一旦 String 对象创建后，包含在这个对象中的字符系列是不可以改变的，直到这个对象被销毁。
• StringBuilder 和 StringBuffer 类型的字符串是可变的。

2. 安全性

• String 的对象是不可变的，可以理解为常量，线程安全。
• StringBuffer 类型线程安全，使用 synchronized 来保证线程安全；而 StringBuilder 类型不是线程安全的。

3. 性能

• 每次操作 String 类型改变其对象时，都会生成新的对象，然后将指针指向新的 String 对象，效率较低。StringBuffer 及 StringBuilder 每次会对对象本身进行操作，不会生成新的对象并改变对象引用，性能相对较好，相同情况下使用 StringBuilder 相比 StringBuffer 能获得 10%-15%性能提升，但 StringBuilder 线程不安全。

4. 使用场景

• 操作少量的字符串：可以直接使用 String 类
• 单线程操作字符串缓冲区大量字符串：使用 StringBuilder 类
• 多线程操作字符串缓冲区大量字符串：使用 StringBuffer 类

欢迎关注微信公众号：Coding我不配
获取更多干货，一起每天进步一点点。