【Java原理探索】带你探究String类不可变的特性 | Java开发实战

简介: 【Java原理探索】带你探究String类不可变的特性 | Java开发实战

前提介绍


在Java中String类的使用的频率可谓相当高。它是Java语言中的核心类,在java.lang包下,主要用于字符串的比较、查找、拼接等等操作。如果要深入理解一个类,最好的方法就是看看源码



什么是字符串

字符串是由引号所括起来的一系列字符序列



字符串类(String)


/** String 类源码 */
public final class String 
     implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[];
    /** Cache the hash code for the string */
    private int hash; // Default to 0
    /** use serialVersionUID from JDK 1.0.2 for interoperability */
    private static final long serialVersionUID = -6849794470754667710L;
    /**
     * Class String is special cased within the Serialization Stream Protocol.
     *
     * A String instance is written into an ObjectOutputStream according to
     * <a href="{@docRoot}/../platform/serialization/spec/output.html">
     * Object Serialization Specification, Section 6.2, "Stream Elements"</a>
     */
    private static final ObjectStreamField[] serialPersistentFields =
        new ObjectStreamField[0];
        ……
}
复制代码


从源码中,可以看出以下几点:


  • String类被final关键字修饰,表示String类不能被继承,且它的属性和方法都被 final 所修饰任何操作都会生成新对象
  • String:: subString(),String::concat() 等方法都会生成一个新的String对象,不会在原对象上进行操作从下面String源码部分中很容易得到上面的结论
  • String类实现了Serializable、CharSequence、 Comparable接口
  • String类的值是通过char数组存储的,并且char数组被private和final修饰,字符串一旦创建就不能再修改



String不可变性


  • String对象一旦被创建就是固定不变的了,对String对象的任何改变都不影响到原对象,相关的任何操作都会生成新的对象


  • String不可变的表现就是当我们试图对一个已有的对象 "abcd" 赋值为 "abcde",String 会新创建一个对象


image.png

注意点


这个无法被修改仅仅是指引用地址不可被修改(也就是说栈里面的这个叫 value 的引用地址不可变,编译器不允许我们把 value 指向堆中的另一个地址),并不代表存储在堆中的这个数组本身的内容不可变。


image.png

那既然我们说String是不可变的,那显然仅仅靠final是远远不够的:


  1. char数组是private的,并且String类没有对外提供修改这个数组的方法,所以它初始化之后外界没有有效的手段去改变它
  2. String类被final修饰的,首先要讲final修饰类的作用,被final修饰的类不能被继承,类中的所有成员方法都会被隐式地指定为final方法。也就是不能拥有子类,成员方法也不能被重写。
  3. String 的所有方法里面,都很小心地避免去修改了char数组中的数据,涉及到对char数组中数据进行修改的操作全部都会重新创建一个String对象



比如 substring 方法:
public String substring(int beginIndex, int endIndex) {
    if (beginIndex < 0) {
        throw new StringIndexOutOfBoundsException(beginIndex);
    }
    if (endIndex > value.length) {
        throw new StringIndexOutOfBoundsException(endIndex);
    }
    int subLen = endIndex - beginIndex;
    if (subLen < 0) {
        throw new StringIndexOutOfBoundsException(subLen);
    }
    return ((beginIndex == 0) && (endIndex == value.length)) ? this
            : new String(value, beginIndex, subLen);
}
复制代码

为什么要设计成不可变的呢?


String被设计成不可变就是为了字符串常量池


  • 字符串常量池的定义
  • 大量频繁的创建字符串,将会极大程度地影响程序的性能,字符串的分配和其他对象分配一样,是需要消耗高昂的时间和空间的,而且字符串我们使用的非常多。JVM为了提高性能和减少内存的开销,所以在实例化字符串的时候使用字符串常量池进行优化。


  • JVM为了提高性能和减少内存开销,在实例化字符串常量的时候进行了一些优化:
  • 字符串开辟了一个字符串常量池 String Pool(HashSet的StringTable),可以理解为缓存区创建字符串常量时,首先检查字符串常量池中是否存在该字符串。


  • 池化思想其实在Java中并不少见,字符串常量池也是类似的思想,当创建字符串时,JVM会首先检查字符串常量池,如果该字符串已经存在常量池中,那么就直接返回常量池中的实例引用。如果字符串不存在常量池中,就会实例化该字符串并且将其放到常量池中



堆内存中只会创建一个 String 对象:
String str1 = "hello";
String str2 = "hello";
System.out.println(str1 == str2) // true


image.png

String允许被改变,那如果我们修改了 str2 的内容为 good,那么 str1 也会被修改,显然这不是我们想要看见的结果


new String(“abc”)创建了几个对象?


  • 如果之前"abc"字符串没有使用过,毫无疑问是创建两个对象,堆中创建了一个String对象,字符串常量池创建了一个,一共两个。
  • 如果之前已经使用过了"abc"字符串,则不会再在字符串常量池创建对象,而是从字符串常量缓冲区中获取,只会在堆中创建一个String对象。
String s1 = "abc";
String s2 = new String("abc");
//s2这行代码,只会创建一个对象
复制代码


String被设计成不可变就是为了安全


  • 作为最基础最常用的数据类型,String 被许多Java类库用来作为参数,如果 String 不是固定不变的,安全性考虑。字符串应用场景众多,设计成不可变性可以有效防止字符串被有意篡改。
  • String被许多的Java类(库)用来当做参数,比如网络连接地址URL,文件路径path,还有反射机制所需要的String参数等,假若String不是固定不变的,将会引起各种安全隐患
  • 在多线程环境下,众所周知,多个线程同时想要修改同一个资源,是存在危险的,而String作为不可变对象,不能被修改,并且多个线程同时读同一个资源,是完全没有问题的,所以String是线程安全的


String被设计成不可变就是为了效率


字符串不变性保证了hash码的唯一性,因此可以放心的进行缓存,这也是一种性能优化手段,意味着不必每次都取计算新的哈希码


String真的不可变吗?


  • String无非就是改变 char 数组 value 的内容,而 value 是私有属性,那么在 Java 中有没有某种手段可以访问类的私有属性呢?
  • 反射,使用反射可以直接修改 char 数组中的内容,当然,一般来说我们不这么做。


看下面代码

image.png

字符串的replace

public String replace(char oldChar, char newChar) {
    if (oldChar != newChar) {
        int len = value.length;
        int i = -1;
        char[] val = value; /* avoid getfield opcode */
        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;
}
复制代码

其他方法也是一样,无论是sub、concat还是replace操作都不是在原有的字符串上进行的,而是重新生成了一个新的字符串对象。




字符串拼接


字符串的拼接在Java中是很常见的操作,但是拼接字符串并不是简简单单地使用"+"号即可,还有一些要注意的点,否则会造成效率低下

public static void main(String[] args) throws Exception {
    String s = "";
    for (int i = 0; i < 10; i++) {
        s+=i;
    }
    System.out.println(s);//0123456789
}
复制代码


在循环内使用+=拼接字符串会有什么问题呢?我们反编译一下看看就知道了。

image.png

  • 其实反编译后,我们可以看到String类使用"+="拼接的底层其实是使用StringBuilder,先初始化一个StringBuilder对象,然后使用append()方法拼接,最后使用toString()方法得到结果。


  • 问题在于如果在循环体内使用+=拼接,会创建很多临时的StringBuilder对象,拼接后再调用toString()赋给原String对象。这会生成大量临时对象,严重影响性能。


所以在循环体内进行字符串拼接时,建议使用StringBuilder或者StringBuffer类,例子如下:

public static void main(String[] args) throws Exception {
    StringBuilder s = new StringBuilder();
    for (int i = 0; i < 10; i++) {
        s.append(i);
    }
    System.out.println(s.toString());//0123456789
}
复制代码
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);
}
复制代码

StringBuilder和StringBuffer的区别在于,StringBuffer的方法都被sync关键字修饰,所以是线程安全的,而StringBuilder则是线程不安全的(效率高)。




总结


并不是因为char数组是final才导致String的不可变,而是为了把String设计成不可变才把 char 数组设置为 final 的


所有不可变类都完全遵守这些规则:


  • 不要提供setter方法(包括修改字段的方法和修改字段引用对象的方法)
  • 将类的所有字段定义为 final、private 的;
  • 不允许子类重写方法。简单的办法是将类声明为 final,更好的方法是将构造函数声明为私有的,通过工厂方法创建对象;
  • 如果类的字段是对可变对象的引用,不允许修改被引用对象。








相关文章
|
10天前
|
缓存 监控 Java
Java虚拟机(JVM)性能调优实战指南
在追求软件开发卓越的征途中,Java虚拟机(JVM)性能调优是一个不可或缺的环节。本文将通过具体的数据和案例,深入探讨JVM性能调优的理论基础与实践技巧,旨在为广大Java开发者提供一套系统化的性能优化方案。文章首先剖析了JVM内存管理机制的工作原理,然后通过对比分析不同垃圾收集器的适用场景及性能表现,为读者揭示了选择合适垃圾回收策略的数据支持。接下来,结合线程管理和JIT编译优化等高级话题,文章详细阐述了如何利用现代JVM提供的丰富工具进行问题诊断和性能监控。最后,通过实际案例分析,展示了性能调优过程中可能遇到的挑战及应对策略,确保读者能够将理论运用于实践,有效提升Java应用的性能。 【
45 10
|
15天前
|
安全 Java 开发者
Java面试题:什么是Java 15中的密封类以及其限制?还有哪些其他特性用于限制类继承的机制吗?
Java面试题:什么是Java 15中的密封类以及其限制?还有哪些其他特性用于限制类继承的机制吗?
18 1
|
3天前
|
存储 算法 Java
Java类是在什么时候加载到JVM中的?加载类时,实际上加载的是什么
Java类是在什么时候加载到JVM中的?加载类时,实际上加载的是什么
|
7天前
|
分布式计算 Java 调度
MaxCompute产品使用合集之使用Tunnel Java SDK上传BINARY数据类型时,应该使用什么作为数据类字节
MaxCompute作为一款全面的大数据处理平台,广泛应用于各类大数据分析、数据挖掘、BI及机器学习场景。掌握其核心功能、熟练操作流程、遵循最佳实践,可以帮助用户高效、安全地管理和利用海量数据。以下是一个关于MaxCompute产品使用的合集,涵盖了其核心功能、应用场景、操作流程以及最佳实践等内容。
|
15天前
|
存储 运维 前端开发
Java面试题:什么是Java的异常处理机制?列举常见的异常类,并说明使用场景
Java面试题:什么是Java的异常处理机制?列举常见的异常类,并说明使用场景
25 0
|
1月前
|
Java UED
Java中String强转int:一种常见的错误和解决方法
在Java中将非数字字符串转换为整数会导致`NumberFormatException`。要解决这个问题,可以使用`try-catch`捕获异常,正则表达式验证数字格式,或利用异常信息提供错误提示。例如,`Integer.parseInt()`会因遇到非数字字符如`&quot;123abc&quot;`而抛出异常,但通过异常处理或正则`\\d+`可确保安全转换。记得在编程时避免直接强转,以防止程序异常中断。
|
23天前
|
安全 Java
Java基础之StringBuffer
【7月更文挑战第1天】 Java中的`StringBuffer`是线程安全的字符串操作类,适合多线程环境,而`StringBuilder`非线程安全,速度更快,适用于单线程。两者提供`append()`、`insert()`、`delete()`等方法修改字符串,避免了频繁创建新对象的性能问题。在不需要线程安全时,推荐使用`StringBuilder`以提高效率。
16 1
|
24天前
|
安全 Java 索引
带你快速掌握Java中的String类和StringBuffer类(详解常用方法 | 区别 )
带你快速掌握Java中的String类和StringBuffer类(详解常用方法 | 区别 )
|
1月前
|
Java 数据处理 Apache
探讨Java中判断String类型为空和null的方法
探讨Java中判断String类型为空和null的方法
21 1
|
1月前
|
Java API 索引
java中String类常用API
java中String类常用API