正文 

当前位置： 首页 > java > java教程

深入理解java：string

     2022-04-24     318

关键词：

在讲解String之前，我们先了解一下Java的内存结构。

一、Java内存模型

按照官方的说法：Java 虚拟机具有一个堆，堆是运行时数据区域，所有类实例和数组的内存均从此处分配。

JVM主要管理两种类型内存：堆和非堆，堆内存（Heap Memory）是在 Java 虚拟机启动时创建，非堆内存(Non-heap Memory)是在JVM堆之外的内存。

简单来说，非堆包含方法区、JVM内部处理或优化所需的内存（如 JITCompiler，Just-in-time Compiler，即时编译后的代码缓存）、每个类结构（如运行时常数池、字段和方法数据）以及方法和构造方法的代码。

Java的堆是一个运行时数据区,类的(对象从中分配空间。这些对象通过new、newarray、 anewarray和multianewarray等指令建立，它们不需要程序代码来显式的释放。堆是由垃圾回收来负责的，堆的优势是可以动态地分配内存大小，生存期也不必事先告诉编译器，因为它是在运行时动态分配内存的，Java的垃圾收集器会自动收走这些不再使用的数据。但缺点是，由于要在运行时动态分配内存，存取速度较慢。

　　栈的优势是，存取速度比堆要快，仅次于寄存器，栈数据可以共享。但缺点是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。栈中主要存放一些基本类型的变量数据（int, short, long, byte, float, double, boolean, char）和对象句柄(引用)。 

虚拟机必须为每个被装载的类型维护一个常量池。常量池就是该类型所用到常量的一个有序集合，包括直接常量（string,integer和 floating point常量）和对其他类型，字段和方法的符号引用。

　　对于String常量，它的值是在常量池中的。而JVM中的常量池在内存当中是以表的形式存在的， 对于String类型，有一张固定长度的CONSTANT_String_info表用来存储文字字符串值，注意：该表只存储文字字符串值，不存储符号引用。说到这里，对常量池中的字符串值的存储位置应该有一个比较明了的理解了。在程序执行的时候,常量池会储存在Method Area,而不是堆中。常量池中保存着很多String对象; 并且可以被共享使用，因此它提高了效率

具体关于JVM和内存等知识请参考：

JVM 基础知识

Java 内存模型及GC原理

二、案例解析

复制代码
复制代码
public static void main(String[] args) {
/**

  • 情景一：字符串池
  • JAVA虚拟机(JVM)中存在着一个字符串池，其中保存着很多String对象;
  • 并且可以被共享使用，因此它提高了效率。
  • 由于String类是final的，它的值一经创建就不可改变。
  • 字符串池由String类维护，我们可以调用intern()方法来访问字符串池。
    */
    String s1 = "abc";
    //↑ 在字符串池创建了一个对象
    String s2 = "abc";
    //↑ 字符串pool已经存在对象“abc”(共享),所以创建0个对象，累计创建一个对象
    System.out.println("s1 == s2 : "+(s1==s2));
    //↑ true 指向同一个对象，
    System.out.println("s1.equals(s2) : " + (s1.equals(s2)));
    //↑ true 值相等
    //↑------------------------------------------------------over
    /**
  • 情景二：关于new String("") 
  •  */  
String s3 = new String("abc");  
//↑ 创建了两个对象，一个存放在字符串池中，一个存在与堆区中；  
//↑ 还有一个对象引用s3存放在栈中  
String s4 = new String("abc");  
//↑ 字符串池中已经存在“abc”对象，所以只在堆中创建了一个对象  
System.out.println("s3 == s4 : "+(s3==s4));  
//↑false   s3和s4栈区的地址不同，指向堆区的不同地址；  
System.out.println("s3.equals(s4) : "+(s3.equals(s4)));  
//↑true  s3和s4的值相同  
System.out.println("s1 == s3 : "+(s1==s3));  
//↑false 存放的地区多不同，一个栈区，一个堆区  
System.out.println("s1.equals(s3) : "+(s1.equals(s3)));  
//↑true  值相同  
//↑------------------------------------------------------over  
/**
  • 情景三：
  • 由于常量的值在编译的时候就被确定(优化)了。
  • 在这里，"ab"和"cd"都是常量，因此变量str3的值在编译时就可以确定。
  • 这行代码编译后的效果等同于： String str3 = "abcd";
    */
    String str1 = "ab" + "cd"; //1个对象
    String str11 = "abcd";
    System.out.println("str1 = str11 : "+ (str1 == str11));
    //↑------------------------------------------------------over
    /**
  • 情景四：
  • 局部变量str2,str3存储的是存储两个拘留字符串对象(intern字符串对象)的地址。
  • 第三行代码原理(str2+str3)：
  • 运行期JVM首先会在堆中创建一个StringBuilder类，
  • 同时用str2指向的拘留字符串对象完成初始化，
  • 然后调用append方法完成对str3所指向的拘留字符串的合并，
  • 接着调用StringBuilder的toString()方法在堆中创建一个String对象，
  • 最后将刚生成的String对象的堆地址存放在局部变量str3中。
  • 而str5存储的是字符串池中"abcd"所对应的拘留字符串对象的地址。
  • str4与str5地址当然不一样了。
  • 内存中实际上有五个字符串对象：
  • 三个拘留字符串对象、一个String对象和一个StringBuilder对象。
    */
    String str2 = "ab"; //1个对象
    String str3 = "cd"; //1个对象
    String str4 = str2+str3;
    String str5 = "abcd";
    System.out.println("str4 = str5 : " + (str4==str5)); // false
    //↑------------------------------------------------------over
    /**
  • 情景五：
  • JAVA编译器对string + 基本类型/常量 是当成常量表达式直接求值来优化的。
  • 运行期的两个string相加，会产生新的对象的，存储在堆(heap)中
    */
    String str6 = "b";
    String str7 = "a" + str6;
    String str67 = "ab";
    System.out.println("str7 = str67 : "+ (str7 == str67));
    //↑str6为变量，在运行期才会被解析。
    final String str8 = "b";
    String str9 = "a" + str8;
    String str89 = "ab";
    System.out.println("str9 = str89 : "+ (str9 == str89));
    //↑str8为常量变量，编译期会被优化
    //↑------------------------------------------------------over
    }
    复制代码
    复制代码

总结：

1.String类初始化后是不可变的(immutable)

这一说又要说很多，大家只要知道String的实例一旦生成就不会再改变了，比如说：String str=”kv”+”ill”+” “+”ans”; 就是有4个字符串常量，首先”kv”和”ill”生成了”kvill”存在内存中，然后”kvill”又和” ” 生成 “kvill “存在内存中，最后又和生成了”kvill ans”;并把这个字符串的地址赋给了str,就是因为String的”不可变”产生了很多临时变量，这也就是为什么建议用StringBuffer的原 因了，因为StringBuffer是可改变的。

　　下面是一些String相关的常见问题：

　　String中的final用法和理解
　　final StringBuffer a = new StringBuffer("111");
　　final StringBuffer b = new StringBuffer("222");
　　a=b;//此句编译不通过 final StringBuffer a = new StringBuffer("111");
　　a.append("222");// 编译通过

　　可见，final只对引用的"值"(即内存地址)有效，它迫使引用只能指向初始指向的那个对象，改变它的指向会导致编译期错误。至于它所指向的对象的变化，final是不负责的。

2.代码中的字符串常量在编译的过程中收集并放在class文件的常量区中，如"123"、"123"+"456"等，含有变量的表达式不会收录，如"123"+a。

3.JVM在加载类的时候，根据常量区中的字符串生成常量池，每个字符序列如"123"会生成一个实例放在常量池里，这个实例是不在堆里的，也不会被GC，这个实例的value属性从源码的构造函数看应该是用new创建数组置入123的，所以按我的理解此时value存放的字符数组地址是在堆里，如果有误的话欢迎大家指正。

4.使用String不一定创建对象

在执行到双引号包含字符串的语句时，如String a = "123"，JVM会先到常量池里查找，如果有的话返回常量池里的这个实例的引用，否则的话创建一个新实例并置入常量池里。如果是 String a = "123" + b (假设b是"456")，前半部分"123"还是走常量池的路线，但是这个+操作符其实是转换成[SringBuffer].Appad()来实现的，所以最终a得到是一个新的实例引用，而且a的value存放的是一个新申请的字符数组内存空间的地址(存放着"123456")，而此时"123456"在常量池中是未必存在的。

要注意: 我们在使用诸如String str = "abc"；的格式定义类时，总是想当然地认为，创建了String类的对象str。担心陷阱！对象可能并没有被创建！而可能只是指向一个先前已经创建的对象。只有通过new()方法才能保证每次都创建一个新的对象

5.使用new String，一定创建对象

在执行String a = new String("123")的时候，首先走常量池的路线取到一个实例的引用，然后在堆上创建一个新的String实例，走以下构造函数给value属性赋值，然后把实例引用赋值给a：

复制代码
复制代码
public String(String original) {
int size = original.count;
char[] originalValue = original.value;
char[] v;
if (originalValue.length > size) {
// The array representing the String is bigger than the new
// String itself. Perhaps this constructor is being called
// in order to trim the baggage, so make a copy of the array.
int off = original.offset;
v = Arrays.copyOfRange(originalValue, off, off+size);
} else {
// The array representing the String is the same
// size as the String, so no point in making a copy.
v = originalValue;
}
this.offset = 0;
this.count = size;
this.value = v;
}
复制代码
复制代码
从中我们可以看到，虽然是新创建了一个String的实例，但是value是等于常量池中的实例的value，即是说没有new一个新的字符数组来存放"123"。

如果是String a = new String("123"+b)的情况，首先看回第4点，"123"+b得到一个实例后，再按上面的构造函数执行。

6.String.intern()

String对象的实例调用intern方法后，可以让JVM检查常量池，如果没有实例的value属性对应的字符串序列比如"123"(注意是检查字符串序列而不是检查实例本身)，就将本实例放入常量池，如果有当前实例的value属性对应的字符串序列"123"在常量池中存在，则返回常量池中"123"对应的实例的引用而不是当前实例的引用，即使当前实例的value也是"123"。

public native String intern();
存在于.class文件中的常量池，在运行期被JVM装载，并且可以扩充。String的 intern()方法就是扩充常量池的 一个方法；当一个String实例str调用intern()方法时，Java 查找常量池中 是否有相同Unicode的字符串常量，如果有，则返回其的引用，如果没有，则在常 量池中增加一个Unicode等于str的字符串并返回它的引用；看示例就清楚了

复制代码
复制代码
public static void main(String[] args) {
String s0 = "kvill";
String s1 = new String("kvill");
String s2 = new String("kvill");
System.out.println( s0 == s1 ); //false
System.out.println( "**" );
s1.intern(); //虽然执行了s1.intern(),但它的返回值没有赋给s1
s2 = s2.intern(); //把常量池中"kvill"的引用赋给s2
System.out.println( s0 == s1); //flase
System.out.println( s0 == s1.intern() ); //true//说明s1.intern()返回的是常量池中"kvill"的引用
System.out.println( s0 == s2 ); //true
}
复制代码
复制代码
最后我再破除一个错误的理解：有人说，“使用 String.intern() 方法则可以将一个 String 类的保存到一个全局 String 表中 ，如果具有相同值的 Unicode 字符串已经在这个表中，那么该方法返回表中已有字符串的地址，如果在表中没有相同值的字符串，则将自己的地址注册到表中”如果我把他说的这个全局的 String 表理解为常量池的话，他的最后一句话，”如果在表中没有相同值的字符串，则将自己的地址注册到表中”是错的：

复制代码
复制代码
public static void main(String[] args) {
String s1 = new String("kvill");
String s2 = s1.intern();
System.out.println( s1 == s1.intern() ); //false
System.out.println( s1 + " " + s2 ); //kvill kvill
System.out.println( s2 == s1.intern() ); //true
}
复制代码
复制代码
在这个类中我们没有声名一个”kvill”常量，所以常量池中一开始是没有”kvill”的，当我们调用s1.intern()后就在常量池中新添加了一 个”kvill”常量，原来的不在常量池中的”kvill”仍然存在，也就不是“将自己的地址注册到常量池中”了。

　　s1==s1.intern() 为false说明原来的”kvill”仍然存在；s2现在为常量池中”kvill”的地址，所以有s2==s1.intern()为true。

StringBuffer与StringBuilder的区别，它们的应用场景是什么？

jdk的实现中StringBuffer与StringBuilder都继承自AbstractStringBuilder，对于多线程的安全与非安全看到StringBuffer中方法前面的一堆synchronized就大概了解了。
这里随便讲讲AbstractStringBuilder的实现原理：我们知道使用StringBuffer等无非就是为了提高java中字符串连接的效率，因为直接使用+进行字符串连接的话，jvm会创建多个String对象，因此造成一定的开销。AbstractStringBuilder中采用一个char数组来保存需要append的字符串，char数组有一个初始大小，当append的字符串长度超过当前char数组容量时，则对char数组进行动态扩展，也即重新申请一段更大的内存空间，然后将当前char数组拷贝到新的位置，因为重新分配内存并拷贝的开销比较大，所以每次重新申请内存空间都是采用申请大于当前需要的内存空间的方式，这里是2倍

【
StringBuffer 始于 JDK 1.0
StringBuilder 始于 JDK 1.5 

从 JDK 1.5 开始，带有字符串变量的连接操作（+），JVM 内部采用的是 
StringBuilder 来实现的，而之前这个操作是采用 StringBuffer 实现的。

】

我们通过一个简单的程序来看其执行的流程：
复制代码
复制代码
public class Buffer {
public static void main(String[] args) {
String s1 = "aaaaa";
String s2 = "bbbbb";
String r = null;
int i = 3694;
r = s1 + i + s2; 

        for(int j=0;i<10;j++){  
            r+="23124";  
        }  
 }

}
复制代码
复制代码
使用命令javap -c Buffer查看其字节码实现：

将清单1和清单2对应起来看，清单2的字节码中ldc指令即从常量池中加载“aaaaa”字符串到栈顶，istore_1将“aaaaa”存到变量1中，后面的一样，sipush是将一个短整型常量值(-32768~32767)推送至栈顶，这里是常量“3694”，更多的Java指令集请查看另一篇文章“Java指令集”。

让我们直接看到13,13~17是new了一个StringBuffer对象并调用其初始化方法，20~21则是先通过aload_1将变量1压到栈顶，前面说过变量1放的就是字符串常量“aaaaa”，接着通过指令invokevirtual调用StringBuffer的append方法将“aaaaa”拼接起来，后续的24~30同理。最后在33调用StringBuffer的toString函数获得String结果并通过astore存到变量3中。

看到这里可能有人会说，“既然JVM内部采用了StringBuffer来连接字符串了，那么我们自己就不用用StringBuffer，直接用”+“就行了吧！“。是么？当然不是了。俗话说”存在既有它的理由”，让我们继续看后面的循环对应的字节码。

37~42都是进入for循环前的一些准备工作，37,38是将j置为1。44这里通过if_icmpge将j与10进行比较，如果j大于10则直接跳转到73，也即return语句退出函数；否则进入循环，也即47~66的字节码。这里我们只需看47到51就知道为什么我们要在代码中自己使用StringBuffer来处理字符串的连接了，因为每次执行“+”操作时jvm都要new一个StringBuffer对象来处理字符串的连接，这在涉及很多的字符串连接操作时开销会很大。 欢迎工作一到五年的Java工程师朋友们加入Java群： 891219277
群内提供免费的Java架构学习资料（里面有高可用、高并发、高性能及分布式、Jvm性能调优、Spring源码，MyBatis，Netty,Redis,Kafka,Mysql,Zookeeper,Tomcat,Docker,Dubbo,Nginx等多个知识点的架构资料）合理利用自己每一分每一秒的时间来学习提升自己，不要再用"没有时间“来掩饰自己思想上的懒惰！趁年轻，使劲拼，给未来的自己一个交代！

《深入理解java虚拟机》string.intern()探究

publicclassRuntimeConstantPoolOOM{publicstaticvoidmain(String[]args){Stringstr1=newStringBuilder("计算机").append("软件").toString();//Stringstr3=newStringBuilder("计算机软件").toString();System.out.println(str 查看详情

jdk学习---深入理解java中的string

本文参考资料：1、《深入理解jvm虚拟机》2、《大话数据结构》、《大化设计模式》3、http://www.cnblogs.com/ITtangtang/p/3976820.html#34410294、http://www.cnblogs.com/xiaoxi/p/6036701.html5、https://www.zhihu.com/question/206188916、http://blog.c 查看详情

《java架构筑基》从java基础讲起——string类深入理解

一.String问题答疑String字符串是如何设计与实现考量的？String字符串缓存intern()方法，由永久代移到堆中。String的演化，Java9中底层把char数组换成了byte数组，占用更少的空间二.String的创建机理由于String在Java世界中使用过于频繁，... 查看详情

读深入理解java中的string（包括jvm）一文总结和提升(代码片段)

 读深入理解Java中的String（包括JVM）一文总结和提升摘要：String作为Java语言中的字符串模拟类，无论是实际的编程工作还是笔试面试过程，都需要我们都String类非常熟悉，对于String类的大部分字符串操作方法，都必须达到熟... 查看详情

java--深入理解字符串的string#intern()方法奥妙之处(代码片段)

学习背景进入正文学习字符串的intern()方法之前，先给下这4个问题，看下自己是否都知道答案？1、Strings1=“a”+“b”;//创建了几个对象？2、Strings2=newString(“ab”);//创建了几个对象？3、Strings3=newStr... 查看详情

使用java语言深入理解程序逻辑——数组

使用Java语言深入理解程序逻辑——数组  一、数组的应用：      1.遍历数组元素：        //使用数组存储五位员工的姓名和薪资           String[]name=newString[5];           int[]salary=newint[5];    ... 查看详情

使用java语言深入理解程序逻辑——数组

使用Java语言深入理解程序逻辑——数组  一、数组的应用：      1.遍历数组元素：        //使用数组存储五位员工的姓名和薪资           String[]name=newString[5];           int[]salary=newint[5];    ... 查看详情

使用java语言深入理解程序逻辑——数组

使用Java语言深入理解程序逻辑——数组  一、数组的应用：      1.遍历数组元素：        //使用数组存储五位员工的姓名和薪资           String[]name=newString[5];           int[]salary=newint[5];    ... 查看详情

深入浅出理解java中的arraylist集合(代码片段)

ArrayList集合importjava.util.ArrayList;publicclassday01publicstaticvoidmain(String[]args)//创建了一个ArrayList集合，集合的名称是list，里面装的是String字符串类型的数据//备注：从jdk1.7+开始，右侧尖括号内容可以不写内容，但是<>本身还是要写... 查看详情

string—深入理解string

...面算是少有的异类，那么特殊在什么地方呢？接下来就让深入的了解String一、特殊之处   (1)、创建特殊性：String对象不能使用newobj指令创建，而是ldstr指令创建，在实现机制上，CLR给了特殊的照顾优化内存  &nbs... 查看详情

深入理解java泛型

泛型是什么一说到泛型，大伙肯定不会陌生，我们代码里面有很多类似这样的语句：List<String>list=newArrayList<>();ArrayList就是个泛型类，我们通过设定不同的类型，可以往集合里面存储不同类型的数据类型（而且只能存储... 查看详情

深入理解java中的引用的含义与原理

一句话：引用就是指向那个对像.Stringstr="aa";str有本身的内存,是一个变量,而对像"aa"也有它自己的内存空间。这时候说str引用"aa"这个对像.Stringtt=null;这里的tt也是一个引用变量,但是它没有引用具体的对像.Stringstr="aa";Stringtt=str;这... 查看详情

json的深入理解

JSON知识JSON(JavaScriptObjectNotataion)javascript的对象表示形式，但是目前已经发展为一种轻量级的数据交互格式。特点：完全独立于语言的文本格式，跨平台，有结构的，方便人和机器来解析。使用场景1.不同语言之间的数据传递（JSON... 查看详情

string类的深入理解(未完待续)(代码片段)

　　String不是基本数据类型，String和8种包装类型是不可变类。String和8种基本数据类型采用值传递。 0.不可变类的设计原则publicfinalclassStringimplementsjava.io.Serializable,Comparable<String>,CharSequence/**Thevalueisusedforcharacterstorag 查看详情

带各位深入理解java1.8之supplier

supplier也是是用来创建对象的，但是不同于传统的创建对象语法：new，看下面代码：publicclassTestSupplier{privateintage;（www.0831jlyy.com）TestSupplier(){System.out.println(age);}publicstaticvoidmain(String[]args){//创建Supplier容器，声明为TestSup 查看详情

深入理解java泛型擦除机制(代码片段)

深入理解Java泛型擦除机制我们都知道Java中的泛型可以在编译期对类型检查，避免类型强制转化带来的问题，保证代码的健壮性。不同语言对泛型的支持也不一样，Java中的泛型类型在编译期会擦除，下面一个例子... 查看详情

深入理解java虚拟机-常用vm参数分析

Java虚拟机深入理解系列全部文章更新中...深入理解Java虚拟机-Java内存区域透彻分析深入理解Java虚拟机-常用vm参数分析深入理解Java虚拟机-JVM内存分配与回收策略原理，从此告别JVM内存分配文盲深入理解Java虚拟机-如何利用JDK自带... 查看详情

c++string的深入理解(代码片段)

String类介绍string的文档介绍字符串是表示字符序列的类标准的字符串类提供了对此类对象的支持，其接口类似于标准字符容器的接口，但添加了专门用于操作单字节字符字符串的设计特性。string类是使用char(即作为它的字... 查看详情