String的内存分配与拼接操作

Posted 龙源lll

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了String的内存分配与拼接操作相关的知识,希望对你有一定的参考价值。

String的基本特性

  • String:字符串,使用一对""引起来表示
  • String的两种实例化的方式:String s1 = "hello";String s2 = new String("hello");
  • String声明为final的,不可被继承
  • String实现了Serializable接口:表示字符串是支持序列化的。
  • String实现了Comparable接口:表示string可以比较大小

String在jdk9中存储结构变更

  • String在jdk8及以前内部定义了final char[] value(每个字符使用两个字节(16位))用于存储字符串数据,但是从许多不同的应用中收集到的数据表明,字符串是堆使用的主要组成部分,大多数字符串对象只包含Latin-1字符,只需要一个字节的存储空间。
  • 在jdk9之后将String类的内部表示方法从UTF-16字符数组改为字节数组(byte[])加编码标志域。新的String类将根据字符串的内容,以ISO-8859-1/Latin-1(每个字符一个字节)或UTF-16(每个字符两个字节)的方式存储字符编码。编码标志将表明使用的是哪种编码。
  • 结论:String再也不用char[] 来存储了,改成了byte [] 加上编码标记,这样使工作时的内存占用减少,GC活动大幅减少。

String:不可变的字符序列

当通过字面量的方式给一个字符串赋值时(String str="Hello";),字符串值声明在字符串常量池中。而在字符串常量池是不会存储相同内容的字符串的。

字符串常量池:
String的String Pool是一个固定大小的Hashtable。如果放进String Pool的String非常多,就会造成Hash冲突严重,从而导致链表会很长,而链表长了后直接会造成的影响就是当调用String.intern时性能会大幅下降。使用-XX:StringTablesize可设置StringTable的长度

  • 在jdk6中StringTable是固定的,就是1009的长度,所以如果常量池中的字符串过多就会导致效率下降很快,StringTablesize设置没有要求。
  • 在jdk7中,StringTable的长度默认值是60013,StringTablesize设置没有要求
  • 在jdk8中,设置StringTable长度的话,1009是可以设置的最小值

String的内存分配

在Java语言中有8种基本数据类型和一种比较特殊的类型String。这些类型为了使它们在运行过程中速度更快、更节省内存,都提供了一种常量池的概念。

常量池就类似一个Java系统级别提供的缓存。8种基本数据类型的常量池都是系统协调的,String类型的常量池比较特殊,存储的主要方法有两种:

  • 直接使用双引号声明出来的String对象会直接存储在常量池中。
  • 如果不是用双引号声明的String对象,可以使用String提供的intern()方法。

在JDK 7以后,内部字符串不再分配在Java堆的永久代中(永久代垃圾回收频率低)而是分配在Java堆的主要部分(年轻代和老年代),所有的字符串都保存在堆中,与应用程序创建的其他对象放在一起。这种变化将导致更多的数据驻留在主Java堆中,而更少的数据在永久代中,因此可能需要调整堆的大小。

在加载许多类或大量使用String.intern()方法的大型应用程序中可以看到这个改动的明显效果。

样例:

class Memory 
    public static void main(String[] args) //line 1
        int i= 1;//line 2
        Object obj = new Object();//line 3
        Memory mem = new Memory();//Line 4
        mem.foo(obj);//Line 5
    //Line 9
    private void foo(Object param) //line 6
        String str = param.toString();//line 7
        System.out.println(str);
    //Line 8

字符串拼接操作

  • 常量与常量的拼接结果在常量池,原理是编译期优化
  • 常量池中不会存在相同内容的变量
  • 只要其中有一个是变量,结果就在堆中。变量拼接的原理是StringBuilder
  • 如果拼接的结果调用intern()方法,则主动将常量池中还没有的字符串对象放入池中,并返回此对象地址

举例1:

public static void test1() 
    // 都是常量,前端编译期会进行代码优化
    String s1 = "a" + "b" + "c";  
    String s2 = "abc"; 

    // true,有上述可知,s1和s2实际上指向字符串常量池中的同一个值
    System.out.println(s1 == s2); 

反编译为class文件后,会发现 String s1 = “abc”; 说明代码在编译期进行了优化

举例2:

public static void test2() 
    String s1 = "javaEE";
    String s2 = "hadoop";

    String s3 = "javaEEhadoop";
    String s4 = "javaEE" + "hadoop";    
    String s5 = s1 + "hadoop";
    String s6 = "javaEE" + s2;
    String s7 = s1 + s2;

    System.out.println(s3 == s4); // true 编译期优化
    System.out.println(s3 == s5); // false s1是变量,不能编译期优化
    System.out.println(s3 == s6); // false s2是变量,不能编译期优化
    System.out.println(s3 == s7); // false s1、s2都是变量
    System.out.println(s5 == s6); // false s5、s6 不同的对象实例
    System.out.println(s5 == s7); // false s5、s7 不同的对象实例
    System.out.println(s6 == s7); // false s6、s7 不同的对象实例

    String s8 = s6.intern();
    System.out.println(s3 == s8); // true intern之后,s8和s3一样,指向字符串常量池中的"javaEEhadoop"

变量拼接原理:
当两个变量:String s1=“a”;String s2=“b”;相加时:其执行细节如下:
①StringBuilder s=new StringBuilder();
②s.append(“a”);
③s.append(“b”);
④s.toString();

举例3:

public void test3()
    String s0 = "ab";
    String s1 = "a";
    String s2 = "b";
    String s3 = s1 + s2;
    System.out.println(s0 == s3); // false s3指向对象实例,s0指向字符串常量池中的"ab"
    String s7 = "cd";
    final String s4 = "c";
    final String s5 = "d";
    String s6 = s4 + s5;
    System.out.println(s6 == s7); // true s4和s5是final修饰的,编译期就能确定s6的值了

字符串拼接操作不一定使用的时StringBuilder,如果使用final修饰,即为常量,会在编译器进行代码优化。如果不使用final修饰,即为变量,会通过new StringBuilder进行拼接。在实际开发中,能够使用final的,尽量使用。

举例4:

字符串拼接操作性能对比:

public class Test    
	public static void main(String[] args)         
		int times = 40000;        
		
		long start = System.currentTimeMillis();        
		
		testString(times);    // String  6963ms    
		//testStringBuilder(times); // StringBuilder    2ms             
		
		long end = System.currentTimeMillis();        
		System.out.println("String: " + (end-start) + "ms");        
		
	
	    
	
	public static void testString(int times)         
		String str = "";        
		for (int i = 0; i < times; i++)             
			str += "test";        
		    
	    
	
	public static void testStringBuilder(int times)         
		StringBuilder sb = new StringBuilder();        
		for (int i = 0; i < times; i++)             
			sb.append("test");        
		    
	    


结果: 通过StringBuilder的append()的方式添加字符串的效率要远高于使用Sting的字符串拼接方式。

详情: StringBuilder的append()方式:自始至终只创建过一个StringBuilder的对象,使用String的字符串拼接方式,执行过程中会创建多个StringBuilder和String对象,内存占用较大,如果进行GC,还需要花费额外的时间。

intern()的使用

intern():将字符串对象尝试放入串池,首先判断字符串常量池中是否存在对应的字符串值,如果存在则返回常量池中字符串的地址,如果不存在,则在常量池中添加该字符串,并返回对应的地址。

intern是一个native方法,调用的是底层C的方法。

Interned string确保字符串在内存里只有一份拷贝,这样可以节约内存空间,加快字符串操作任务的执行速度。注意,这个值会被存放在字符串内部池(String Intern Pool)。

空间效率:对于程序中大量使用存在的字符串时,尤其存在很多已经重复的字符串时,使用intern()方法能够节省内存空间。


面试题:new String(“ab”)会创建几个对象?

String s = new String("ab");创建了两个对象:堆空间中一个new对象 ,字符串常量池中一个字符串常量"ab"(如果此时字符串常量池中已有该常量则不会创建)

面试题:new String(“a”)+new String(“b”)会创建几个对象?


intern的使用:

jdk6中intern的使用:false false

String s = new String("1") 创建了两个对象(new对象,字符串常量)
② s.intern()由于字符串常量池中已存在"1" ,s 指向的是堆空间中的对象地址,s2 指向的是堆空间中常量池中"1"的地址
③:s3变量记录的地址为:new String("11");,但在字符串常量池中并没有生成字符串"11"
④:s3.intern()在字符串常量池中生成"11"(一个新的对象)
⑤:s4指向字符串常量池中"11"的地址,所以s3与s4指向的地址不同

jdk7/8中intern的使用:false true


在jdk7/8中, s3.intern() ,由于已经存在new String("11");,会在常量池中生成"11"的引用地址指向new String("11");,s4会指向上一行代码执行时,在常量池中生成的"11"的引用地址,所以s3 和 s4 指向的都是一个地址。

总结:
①:在jdk6中,如果串池中有,则并不会放入。返回已有的串池中的对象的地址,如果没有,会把此对象复制一份,放入串池,并返回串池中的对象地址。
②:在jdk7/8中,如果串池中有,则并不会放入。返回已有的字符串常量池中的对象的地址如果没有,则会把对象的引用地址复制一份,放入串池,并返回串池中的引用地址。


练习:

jdk6中:s.intern()在字符串常量池中创建一个字符串"ab",s2指向"ab",执行结果:true false

jdk7/8中:s.intern()没有创建字符串"ab",而是创建了一个引用,指向new String(“ab”);,s与s2都指向该地址,执行结果:true true


以上是关于String的内存分配与拼接操作的主要内容,如果未能解决你的问题,请参考以下文章

面试中必须要掌握的String字符串的知识点

Java内存与垃圾回收篇(对象内存与垃圾回收机制)上篇

StringBuffer与StringBuilder的区别

STL体系结构基础介绍

有关C++指针与安全阐述

C++ Primer 5th笔记(chap 19 特殊工具与技术)控制内存分配