String内存分配情况解析 -

夏文权

浏览: 237529 次
性别:
来自: 贵州

最近访客更多访客>>

prestlhh

dupz

sml940813

yaozhifeng123456

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

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];

    /**
     * Initializes a newly created {@code String} object so that it represents
     * an empty character sequence.  Note that use of this constructor is
     * unnecessary since Strings are immutable.
     */
    public String() {
        this.value = "".value;
    }
}

以上是jdk1.8中对String类的定义，看得出以下几个结论：

String 类被final关键字修饰，因此String类不能被继承，并且它的成员方法都默认为final方法；字符串一旦创建就不能再修改。
String 类实现了Serializable、CharSequence、 Comparable接口。
String 实例的值是通过字符数组实现字符串存储的。

StringBuilder

可变的字符序列，StringBuffer的append方法使用了synchronized，所以是线程安全的，StringBuilder的效率比StringBuffer快。

StringBuffer

可变的字符序列，StringBuffer是线程不安全的。，StringBuffer的效率比StringBuffer慢。

在java中当"+" 前后出现字符串时表示字符串拼接的操作，因为String是final修饰的，创建后就不可变，所以“+”底层实际是创建了一个StringBuilder对象，然后调用append方法去拼接字符串，再调用toString方法生成一个新的String。
只有使用引号包含文本的方式创建的String对象之间使用 “+” 连接产生的新对象才会被加入字符串池中。

例如：String s5 = "a" + "b";直接在堆内存中的字符串池创建b这个对象

所有包含new方式新建对象（包括null）的 “+” 连接表达式，它所产生的新对象都不会被加入字符串池中。

例如：

String s3 = new String("a");

String s4 = new String("b");

String s5 = s3 + s4;

intern方法

    /**
     * Returns a canonical representation for the string object.
     * <p>
     * A pool of strings, initially empty, is maintained privately by the
     * class {@code String}.
     * <p>
     * When the intern method is invoked, if the pool already contains a
     * string equal to this {@code String} object as determined by
     * the {@link #equals(Object)} method, then the string from the pool is
     * returned. Otherwise, this {@code String} object is added to the
     * pool and a reference to this {@code String} object is returned.
     * <p>
     * It follows that for any two strings {@code s} and {@code t},
     * {@code s.intern() == t.intern()} is {@code true}
     * if and only if {@code s.equals(t)} is {@code true}.
     * <p>
     * All literal strings and string-valued constant expressions are
     * interned. String literals are defined in section 3.10.5 of the
     * <cite>The Java&trade; Language Specification</cite>.
     *
     * @return  a string that has the same contents as this string, but is
     *          guaranteed to be from a pool of unique strings.
     */
    public native String intern();

intern方法是一个本地方法。作用就是调用该方法时先去字符串常量池中查找是否有相等的（equals）值，有就直接返回常量池中的引用。没有就将该字符串存入字符串常量池，再返回字符串常量池中的引用。

注意：jkd1.6之前常量池和堆是分开的，所以这里是在常量池里存的的具体的值。jdk1.6之后常量池和堆在一起，这里常量池中保存的是堆中对象的引用。

String 创建对象在内存结构以及常见的对象数量问题解析

创建对象有2种方式

通过常量池创建

JVM会首先检查在字符串常量池，如果在字符串常量池中存在了该字符串，则将该字符串对象的地址值赋值给引用。如果字符串不在常量池中，就会在常量池中创建字符串,然后将字符串对象的地址值交给引用。所以最多只会创建一个对象。

实例分析

String s1 = "a";
String s3 = new String("a");
String s4 = new String("b");
String s2 = "b";
String s5 = "a" + "b";
String s6 = "a" + s4;
String s7 = s1 + s2;
String s8 = "ab";
final String s9 = "e";
final String s10 = "f";
String s11 = s9 + s10;
String s12 = "ef";
System.out.println(s1 == s3);        // false
System.out.println(s1.equals(s3));	 // true
System.out.println(s5 == s6);		// false
System.out.println(s5 == s7);		// false
System.out.println(s5.equals(s7));	// true
System.out.println(s5 == s8);		// true
System.out.println(s11 == s12);		// true

画图分析

String内存分布和创建时对象生成情况等常见问题详解

结果分析


s1 在常量池中生成了一个对象
s3 常量池中已经有了，所以只在堆中创建了一个对象
s4 常量池和堆中各创建了一个对象，共两个对象（这两个对象的字符串数组是同一个）
s2 常量池中已经有了，没有重新创建对象
s5 编译时将常量拼接好了，然后在常量池中创建了一个对象
s6 生成一个StringBuilder对象用来拼接，最后toSting在堆中生成一个新的对象，共两个对象
s7 与s6一样
s8 常量池中已经有了，没有重新创建对象
s9，s10都是在常量池中生成一个对象
s11 使用final修饰的变量，在编译时替换成常量了，然后将常量拼接好在常量池中创建了一个对象

通过new创建

JVM会首先检查字符串常量池,如果字符串已经存在常量池中，直接复制堆中这个对象的副本，然后将堆中的地址值赋给引用，不会在字符串常量池中创建对象。如果字符串不存在常量池中，就会实例化该字符串并且将其放到常量池中，然后在堆中复制该对象的副本，并将对象的地址值交给引用。所以可能生成一个或者两个对象。

实例分析

String s1 = new String("g");
s1.intern();
String s2 = "g";
System.out.println(s1 == s2);           // false
System.out.println(s1.intern() == s2);   // true

String s3 = new String("h") + new String("i");
s3.intern();
String s4 = "hi";
System.out.println(s3 == s4);           // true
System.out.println(s3.intern() == s4);   // true

String s5 = new String("j") + new String("k");
String s6 = "jk";
s5.intern();
System.out.println(s5 == s6);           // false
System.out.println(s5.intern() == s6);   // true

画图分析

String内存分布和创建时对象生成情况等常见问题详解

结果分析


s1 在常量池中和堆中各创建了一个对象
s1.intern调用时发现常量池中已经存在“g”了，所以返回常量池中“g”的引用
s2 创建时发现常量池中已经存在了，不会生成新的对象，直接指向常量池的对象
s1和s2指向不同的对象，所以不相等。s1.intern指向常量池的对象，和s2相等
s3 在堆中生成两个匿名对象，一个StringBuilder对象，一个toString生成的对象，常量池中两个对象，共六个对象。最终生成的对象不会存放到字符串常量池中（参考上面“+”的定义）。
s3.intern调用时发现常量池中没有“hi”，将堆中“hi”对象的地址存放在常量池中，所以s3.intern最终还是指向堆中的对象。
s4 创建时发现常量池中已经存在了，直接返回常量池中的引用，所以s4最终也指向了堆中的“hi”对象。所以s3==s4，s3.intern() == s4
s5 创建和s3过程一样
s6 创建时发现常量池中没有，会在常量池中创建一个“jk”对象
s5.intern调用时，发现常量池中已经存在“jk”，直接返回常量池中的对象地址。
所以s5和s6是指向不同的对象

注明：本文参考和引用 "String内存分布和创建时对象生成情况等常见问题详解"这篇文章

“https://www.toutiao.com/i6981781517945111052/?tt_from=weixin&utm_campaign=client_share&wxshare_count=1&timestamp=1625616592&app=news_article&utm_source=weixin&utm_medium=toutiao_android&use_new_style=1&req_id=202107070809520101512082132E0BAAEA&share_token=74b9e806-66c2-4911-8763-3585b2b7a411&group_id=6981781517945111052”

分享到：