深入理解字符串（附面试题）

字符串介绍

字符串是程序开发中使用最频繁的类型之一，具有与基本类型相同的地位，甚至在 JVM（Java 虚拟机)编译时会对字符串进行特殊处理，如拼加操作可能会被处理 JVM 直接合成为最终字符串，从而达到高效运行的目的。

1 String 特性

• String 是标准的不可变类（immutable），事实上，任何改变都是为了创建一个新的对象，然后引用对象；
• String 对象赋值后，将在常量池中缓存。如果下次创建，将确定常量池是否有缓存对象，如果有，将直接返回给创建者。

2 字符串创建

创建字符串的方法有两种：

• String str = "laowang";
• String str = new String("laowang");

3 注意事项

查看以下代码：

String s1 = "laowang";String s2 = s1;String s3 = new String(s1);System.out.println(s1 == s2);System.out.println(s1 == s3);

输出结果：true、false。

为什么会这样？原因是 s3 使用 new String 内存区域肯定会在堆中重新创建， s2 它将直接使用 s1 引用，所以结果也完全不同。

使用1字符串 字符串拼加

字符串拼的方法有几种:

• String str = "lao" + "wang";
• String str = "lao"; str += "wang";
• String str = "lao"; String str2 = str + "wang";

2 JVM 优化字符串

根据以前的知识，我们知道，对于 String 任何操作实际上都是创建一个新的对象，然后将引用地址返回到对象，但是 JVM 也会对 String 提供程序运行效率的特殊处理，如以下代码：

String str = "hi," + "lao" + "wang";

经过 JVM 优化后的代码如下：

String str = "hi,laowang";

验证代码如下：

String str = "hi," + "lao" + "wang";String str2 = "hi,laowang";System.out.println(str == str2);

执行结果：true。

这就说明 JVM 在某些情况下，会特殊处理 String 类型。

3 字符串截取

截取使用字符串 substring() 使用方法如下：

String str = "abcdef";// 结果：cdef(从下标为2的截取到最后，包括下标的开始)System.out.println(str.substring(2));// 结果：cd(从下标2截取到下标4，包括开始下标，不包括结束下标。System.out.println(str.substring(2,4));

4 字符串格式化

字符串的格式化可以使代码更简洁、更直观。例如，“我叫老王，今年 30 在这个信息中：姓名、年龄、兴趣是动态变化的，如果使用“+”拼接很容易出错，此时字符串格式化方法 String.format() 派上用场，代码如下：

String str = String.format("我叫%s，今年%d岁，喜欢%d岁s", "老王", 30, "读书");

转换符说明列表：

转换符

说明

%s

字符串类型

%d

整数类型(十进制)

%c

字符类型

%b

布尔类型

%x

整数类型(十六进制)

%o

整数类型(八进制)

%f

浮点类型

%a

浮点类型(16进制)

%e

指数类型

%%

百分比类型

%n

换行符

5 字符对比

根据以前的知识，我们知道使用它 String 和 new String 声明的对象是不同的。有没有一个简单的方法可以忽略它们的创建方法（是否有 new）只比较它们的值是否相同？答案是肯定的，使用 equals() 该方法可实现，代码如下：

String s1 = "hi," + "lao" + "wang";String s2 = "hi,";s2 += "lao";s2 += "wang";String s3 = "hi,laowang";System.out.println(s1.equals(s2)); // trueSystem.out.println(s1.equals(s3)); // trueSystem.out.println(s2.equals(s3)); // true

以上使用 equals 比较的结果都是 true。

如果要忽略字符串的大小写对比值，可以使用 equalsIgnoreCase()，代码示例：

String s1 = "Hi,laowang";String s2 = "hi,laowang";System.out.println(s1.equals(s2)); // falseSystem.out.println(s1.equalsIgnoreCase(s2)); // true

s1.equals(s2) 执行结果如下：false，s1.equalsIgnoreCase(s2) 执行结果如下：true。

6 String、StringBuffer、StringBuilder

主要有三种类型的字符串相关：String、StringBuffer、StringBuilder，其中 StringBuffer、StringBuilder 都是可变字符串类型，StringBuffer 拼接字符串时使用 synchronized 确保线程安全，因此，建议在多线程字符串拼接中使用 StringBuffer。

StringBuffer 使用：

StringBuffer sf = new StringBuffer("lao");// 添加字符串到尾部sf.append("wang"); // 执行结果：laowang// 将字符串插入到当前字符串下标的位置sf.insert(0,"hi,"); // 执行结果：hi,laowang// 修改字符中下标值的sf.setCharAt(0,'H'); // 执行结果：Hi,laowang

StringBuilder 使用方法及 StringBuffer 同样，它们都是继承的 AbstractStringBuilder。

相关面试题1. String 属于基础数据类型吗？

答：String 它不是基础数据类型，而是从堆上分配的。基础数据类型有 8 分别为：boolean、byte、short、int、long、float、double、char。

2. 字符串长度可以正确获得以下内容吗？

A：str.lengthB：str.sizeC：str.length()D：str.size()

答：C

主题分析：没有字符串 length 属性，只有 length() 方法。

3. "==" 和 equals 有什么区别？

答:“==” 对于基本类型是值比较，对于引用类型是引用；而 equals 默认情况下是引用比较，但重写的类别很多 equals 方法，比如 String、Integer 等它变成值比较，所以一般情况下 equals 比较值是否相等。

① "==" 解读

基本类型和引用类型 == 效果不同，如下所示：

• 基本类型：比较值是否相同；
• 引用类型：比较引用是否相同。

代码示例：

String x = "string";String y = "string";String z = new String("string");System.out.println(x==y); // trueSystem.out.println(x==z); // falseSystem.out.println(x.equals(y)); // trueSystem.out.println(x.equals(z)); // true

代码说明:因为 x 和 y 指向相同的引用，所以 == 也是 true，而 new String() 方法则重写开辟了内存空间，因此 == 结果为 false，而 equals 比较一直是值，所以结果都是 true。

② equals 解读

equals 本质上就是 ==，只不过 String 和 Integer 等重写了 equals 方法，把它变成值比较。看下面的代码就知道了。

首先看默认情况 equals 比较具有相同值的对象，代码如下：

class Cat {    public Cat(String name) {        this.name = name;    }    private String name;    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }}Cat c1 = new Cat(王磊);Cat c2 = new Cat(王磊);System.out.println(c1.equals(c2)); // false

输出结果出乎我们的意料，实际上是 false？！

看到这是怎么回事 equals 就知道源码了，源码如下：

public boolean equals(Object obj) {    return (this == obj);}

原来 equals 本质上就是 ==。

问题来了，两个相同的值 String 对象，为什么返回？ true？代码如下：

String s1 = new String(老王);String s2 = new String(老王);System.out.println(s1.equals(s2)); // true

同样，当我们进去的时候 String 的 equals 方法，找到答案，代码如下：

public boolean equals(Object anObject) {    if (this == anObject) {        return true;    }    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) {                if (v1[i] != v2[i])                    return false;                i++;            }            return true;        }    }    return false;}

原来是 String 重写了 Object 的 equals 该方法将引用比较改为值比较。

综上所述，“==” 对于基本类型是值比较，对于引用类型是引用； equals 默认情况下是引用比较，但重写的类别很多 equals 方法，比如 String、Integer 等它变成值比较，所以一般情况下 equals 比较值是否相等。

4. 以下代码输出的结果是什么？

String str = "laowang";str.substring(0,1);System.out.println(str);

A：lB：aC：laD：laowang

答：D

题目分析:因为 String 的 substring() 方法不会修改原字符串的内容，所以结果仍然是 laowang。

5. 对比以下字符串的结果是什么？

String s1 = "hi," + "lao" + "wang";String s2 = "hi,";s2 += "lao";s2 += "wang";String s3 = "hi,laowang";System.out.println(s1 == s2);System.out.println(s1 == s3);System.out.println(s2 == s3);

答：false true false

题目解析：String s1 = "hi," + "lao" + "wang" 代码会被 JVM 优化为：String s1 = "hi,laowang这样就和了 s3 s1完全一样 创建时，字符将被“创建”hi,laowang“放入常量池，s3 常量池创建时，已经存在相应的缓存，引用返回将直接返回 s3，所以 s1==s3 就为 true，而 s2 使用了 += 引用地址与其他两个不同。

6. 以下 String 传值修改后的结果是什么？

public static void main(String[] args) {  String str = new String("laowang");  change(str);  System.out.println(str);}public static void change(String str) {    str = "xiaowang";}

答：laowang

7. 以下 StringBuffer 传值修改后的执行结果是什么？

public static void main(String[] args) {  StringBuffer sf = new StringBuffer("hi,");  changeSf(sf);  System.out.println(sf);}public static void changeSf(StringBuffer sf){    sf.append("laowang");}

答：hi,laowang

题目解析：String 在方法内对不可变类型 String 修改时，相当修改传递的是一个 String 副本，所以 String 本身的值不会被修改，但是 StringBuffer 对于可变类型，参数传递的是对象的引用，修改本身就会发生变化。

8. 以下使用 substring 执行的结果是什么？

String str = "abcdef";System.out.println(str.substring(3, 3));

答：“(空)。

9. 有几种方法可以判断字符串是否为空？

答:常用的方法有以下两种。

• str.equals("")
• str.length()==0

10. String、StringBuffer、StringBuilder 的区别？

答：以下是 String、StringBuffer、StringBuilder 的区别：

• 可变性：String 字符串常量是不可变的对象，StringBuffer 与 StringBuilder 字符串变量是可变对象；
• 性能：String 每次修改相当于生成一个新对象，因此性能最低；StringBuffer 使用 synchronized 确保线程安全，性能优于 String，但不如 StringBuilder；
• 线程安全：StringBuilder 非线程安全类，StringBuffer 线程安全类。

11. String 对象的 intern() 它有什么作用？

答：intern() 该方法用于查找常量池中是否存在字符值。如果常量池不存在，则首先在常量池中创建，如果存在，则直接返回。

示例代码：

String s = "laowang";String s2 = s.intern();System.out.println(s == s2); // 返回 true

12. String s=new String("laowang") 创建了多少对象？

答:共创建了两个对象，一个是字符串 “laowang另一种是指向字符串的变量 s。new String() 无论常量池是否有相同的字符串，都会在内存(非字符串常量池)中创建新的对象。

13. 字符串常量池是什么？

字符串常量池存储在字符串中 Java 堆内存中的字符串池是防止每次新字符串带消耗时间和空间的解决方案。创建字符串时 JVM 首先检查字符串常量池。如果字符串已经存在于池中，请返回池中的示例参考。如果字符串不在池中，则将示例字符串放入池中，并将当前引用指向字符串。

14. String 不可变性有什么好处？

答:不可变的好处如下。

• 只有当字符串不可变时，才能实现字符串常量池。字符串池的实现可以节省大量的运行空间，因为不同的字符串变量指向池中的同一字符串；
• 例如，可以避免一些安全漏洞 Socket 在编程中，主机名称和端口以字符串的形式传输，因为字符串是不可改变的，所以它的值是不可改变的，否则黑客可以钻漏洞，改变字符串指向的对象值，造成安全漏洞；
• 多线程安全，因为字符串是不可变的，所以同一字符串的例子可以由多线程共享，以确保多线程的安全；
• 适合缓存 key，由于字符串是不可变的，哈希值在创建时被缓存，不需要更快地重新计算，因此字符串非常适合缓存 key。

15. String 是否可以继承？为什么？

答：String 不能继承。因为 String 被声明为 final(最终类)不能继承，源代码如下（JDK 8）。

public final class String    implements java.io.Serializable, Comparable<String>, CharSequence {    //...}