面试官常问的String细节

偏执的太偏执、 2022-11-06 03:00 207阅读 0赞

> 微信公众号：**Java随笔录**  
> 关注可了解更多Java相关的技术分享。问题或建议，欢迎公众号留言！

### 文章目录 ###

*   *   *  前言
         *  关于String
         *   *  将String设计成不可变类的原因
         *  代码示例
         *  String的创建方式
         *   *  1. 直接赋值法
             *  2. 构造器方法
         *  分析
         *  常用方法
         *  String的相关类
         *  公众号

### 前言 ###

在我们的日常编程中，字符串的使用必不可少。而在Java中，字符串属于对象，其针对字符串提供了String类，同时还根据常见的字符串操作提供了相应的创建方法以及操作函数。

相信你能够很熟练的使用Java新建一个字符串对象，并对该字符串对象执行一系列的变换操作，但是关于String类的一些细节你很可能没有了解过，这里小录给大家做了一点总结。

### 关于String ###

如下所示，从String类的定义中可以看到，它被修饰为final类型，即不可变类（更多关于final关键字的讲解，可以看这篇文章[深入理解final关键字][final]），而这一细节，是面试官经常问及的点。

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

#### 将String设计成不可变类的原因 ####

在笔者看来，将String设计成不可变类主要是出于效率以及安全的考虑：

**效率：**

1). 在JVM的早期版本中，用final修饰的方法会被转为内嵌调用，可以在一定程度上提高代码的执行效率；

2). String对象不可变，其hashcode也就不变，于是在创建对象时其hashcode就可以放心的进行缓存，无需考虑对象改变时重新进行计算。

**安全：**

在网络连接和数据库连接中字符串常常作为参数，例如，网络连接地址URL，文件路径path，反射机制所需要的String参数。其不可变性可以保证连接的安全性。如果字符串是可变的，会出现意想不到的结果。

### 代码示例 ###

下面通过一段代码来展示String类的特点，你能否直接说出每一行输出的结果呢？

public class Test { 
        public static void main(String[] args) { 
            String str1 = "HelloWorld";
            String str2 = "HelloWorld";
            String str3 = new String("HelloWorld");
            String str4 = "Hello";
            String str5 = "World";
            String str6 = "Hello" + "World";
            String str7 = str4 + str5;
    
            System.out.println("str1 == str2 result: " + (str1 == str2));
    
            System.out.println("str1 == str3 result: " + (str1 == str3));
    
            System.out.println("str1 == str6 result: " + (str1 == str6));
    
            System.out.println("str1 == str7 result: " + (str1 == str7));
    
            System.out.println("str1 == str7.intern() result: " + (str1 == str7.intern()));
    
            System.out.println("str3 == str3.intern() result: " + (str3 == str3.intern()));
        }
    }

### String的创建方式 ###

如上述代码所示，String的创建方式主要有两种：

#### 1. 直接赋值法 ####

此方式在方法区中字符串常量池中创建对象

String str = "world";

#### 2. 构造器方法 ####

此方式在堆内存创建对象

String str = new String("world");

### 分析 ###

要彻底理解String，那么要了解JVM内存中的栈(stack)、堆(heap)和方法区。简要图如下：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0pfX01heA_size_16_color_FFFFFF_t_70_pic_center]

*  str1 == str2

String str1 = "HelloWorld";
    String str2 = "HelloWorld";
        
    System.out.println(str1 == str2); // true

当执行第一句时，JVM会先去常量池中查找是否存在HelloWorld，当存在时直接返回常量池里的引用；当不存在时，会在字符串常量池中创建一个对象并返回引用。

当执行第二句时，同样的道理，由于第一句已经在常量池中创建了，所以直接返回上句创建的对象的引用。

*  str1 == str3

String str1 = "HelloWorld";
    String str3 = new String("HelloWorld");
        
    System.out.println(str1 == str3); // false

执行第一句，同上。

执行第二句时，会在堆（heap）中创建一个对象，当字符串常量池中没有HelloWorld时，会在常量池中也创建一个对象；当常量池中已经存在了，就不会创建新的了。

*  str1 == str6

String str1 = "HelloWorld";
    String str6 = "Hello" + "World";
        
    System.out.println(str1 == str6); // true

由于"Hello"和"World"都是常量，编译时，第二句会被自动编译为String str6 = “HelloWorld”;

*  str1 == str7

String str1 = "HelloWorld";
    String str4 = "Hello";
    String str5 = "World";
    String str7 = str4 + str5;
        
    System.out.println(str1 == str7); // false

其中前三句变量存储的是常量池中的引用地址。

第四句执行时，JVM会在堆（heap）中创建一个以str4为基础的一个StringBuilder对象，然后调用StringBuilder的append()方法完成与str5的合并，之后会调用toString()方法在堆（heap）中创建一个String对象，并把这个String对象的引用赋给str7。

### 常用方法 ###

下面是 String 类支持的方法，更多详细，参看 Java String API 文档:

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>char charAt(int index)</td> 
   <td>返回指定索引处的 char 值。</td> 
  </tr> 
  <tr> 
   <td>int compareTo(Object o)</td> 
   <td>把这个字符串和另一个对象比较。</td> 
  </tr> 
  <tr> 
   <td>int compareTo(String anotherString)</td> 
   <td>按字典顺序比较两个字符串。</td> 
  </tr> 
  <tr> 
   <td>boolean endsWith(String suffix)</td> 
   <td>测试此字符串是否以指定的后缀结束。</td> 
  </tr> 
  <tr> 
   <td>boolean equals(Object anObject)</td> 
   <td>将此字符串与指定的对象比较。</td> 
  </tr> 
  <tr> 
   <td>boolean equalsIgnoreCase(String anotherString)</td> 
   <td>将此 String 与另一个 String 比较，不考虑大小写。</td> 
  </tr> 
  <tr> 
   <td>byte[] getBytes()</td> 
   <td>使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。</td> 
  </tr> 
  <tr> 
   <td>byte[] getBytes(String charsetName)</td> 
   <td>使用指定的字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。</td> 
  </tr> 
  <tr> 
   <td>int indexOf(int ch)</td> 
   <td>返回指定字符在此字符串中第一次出现处的索引。</td> 
  </tr> 
  <tr> 
   <td>int indexOf(int ch, int fromIndex)</td> 
   <td>返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。</td> 
  </tr> 
  <tr> 
   <td>int indexOf(String str)</td> 
   <td>返回指定子字符串在此字符串中第一次出现处的索引。</td> 
  </tr> 
  <tr> 
   <td>int indexOf(String str, int fromIndex)</td> 
   <td>返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。</td> 
  </tr> 
  <tr> 
   <td>String intern()</td> 
   <td>返回字符串对象的规范化表示形式。</td> 
  </tr> 
  <tr> 
   <td>int lastIndexOf(int ch)</td> 
   <td>返回指定字符在此字符串中最后一次出现处的索引。</td> 
  </tr> 
  <tr> 
   <td>int lastIndexOf(int ch, int fromIndex)</td> 
   <td>返回指定字符在此字符串中最后一次出现处的索引，从指定的索引处开始进行反向搜索。</td> 
  </tr> 
  <tr> 
   <td>int lastIndexOf(String str)</td> 
   <td>返回指定子字符串在此字符串中最右边出现处的索引。</td> 
  </tr> 
  <tr> 
   <td>int lastIndexOf(String str, int fromIndex)</td> 
   <td>返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。</td> 
  </tr> 
  <tr> 
   <td>int length()</td> 
   <td>返回此字符串的长度。</td> 
  </tr> 
  <tr> 
   <td>boolean matches(String regex)</td> 
   <td>告知此字符串是否匹配给定的正则表达式。</td> 
  </tr> 
  <tr> 
   <td>String replace(char oldChar, char newChar)</td> 
   <td>返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。</td> 
  </tr> 
  <tr> 
   <td>String replaceAll(String regex, String replacement)</td> 
   <td>使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。</td> 
  </tr> 
  <tr> 
   <td>String replaceFirst(String regex, String replacement)</td> 
   <td>使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。</td> 
  </tr> 
  <tr> 
   <td>String[] split(String regex)</td> 
   <td>根据给定正则表达式的匹配拆分此字符串。</td> 
  </tr> 
  <tr> 
   <td>String[] split(String regex, int limit)</td> 
   <td>根据匹配给定的正则表达式来拆分此字符串。</td> 
  </tr> 
  <tr> 
   <td>boolean startsWith(String prefix)</td> 
   <td>测试此字符串是否以指定的前缀开始。</td> 
  </tr> 
  <tr> 
   <td>boolean startsWith(String prefix, int toffset)</td> 
   <td>测试此字符串从指定索引开始的子字符串是否以指定前缀开始。</td> 
  </tr> 
  <tr> 
   <td>String substring(int beginIndex)</td> 
   <td>返回一个新的字符串，它是此字符串的一个子字符串。</td> 
  </tr> 
  <tr> 
   <td>String substring(int beginIndex, int endIndex)</td> 
   <td>返回一个新字符串，它是此字符串的一个子字符串。</td> 
  </tr> 
  <tr> 
   <td>char[] toCharArray()</td> 
   <td>将此字符串转换为一个新的字符数组。</td> 
  </tr> 
  <tr> 
   <td>String toLowerCase()</td> 
   <td>使用默认语言环境的规则将此 String 中的所有字符都转换为小写。</td> 
  </tr> 
  <tr> 
   <td>String toUpperCase()</td> 
   <td>使用默认语言环境的规则将此 String 中的所有字符都转换为大写。</td> 
  </tr> 
  <tr> 
   <td>String trim()</td> 
   <td>返回字符串的副本，忽略前导空白和尾部空白。</td> 
  </tr> 
 </tbody> 
</table>

### String的相关类 ###

由于String的不可变性导致字符串变化时效率低下，在之后的JDK版本中出现了StringBuilder和StringBuffer，他们之间的差别大致如下，在后续的文章中，小录会对他们进行深入总结。

<table> 
 <thead> 
  <tr> 
   <th>类</th> 
   <th>可变性</th> 
   <th>线程安全</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>String</td> 
   <td>不可变</td> 
   <td>安全</td> 
  </tr> 
  <tr> 
   <td>StringBuffer</td> 
   <td>可变</td> 
   <td>安全</td> 
  </tr> 
  <tr> 
   <td>StringBuilder</td> 
   <td>可变</td> 
   <td>非安全</td> 
  </tr> 
 </tbody> 
</table>

### 公众号 ###

*  关注公众号，即时接收关于Java的技术分享！

![20210207183855124.JPG][]

[final]: https://jiangnanmax.blog.csdn.net/article/details/114340515
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0pfX01heA_size_16_color_FFFFFF_t_70_pic_center]: /images/20221023/99d53fff77494b51bf078d4d2b87f975.png
[20210207183855124.JPG]: /images/20221023/add857a6d15e43539e303e2031ec7633.png