八 8.1 — String内容浅析

学习渠道：尚硅谷[宋红康]

八 8.1 --- String内容浅析

八 8.1 --- String内容浅析1，String的基本特性2，String的内存分配3，String的基本操作3，1 **String的拼接操作**3，2 字符串拼接的底层原理3，3 拼接和StringBuild的append()操作的效率对比 4，String的intern()的使用5，通过面试题来更好的了解String5，1 new String("ab") 会创建几个对象?5，2 new String("a" ) + new String("b")呢?5，3 intern()面试题 6，intern的效率测试7，StringTable的垃圾回收8，G1中的String的去重操作

1，String的基本特性

String:字符串，使用- -对""引起来表示。 String a = “hello world”;//字面量方式定义String b = new String(“hello world”);//新建对象方式定义 String声明为final的，不可被继承String实现了Serializable接口:表示字符串是支持序列化的。 实现了Comparable接口:表示String可以比较大小String在jdk8及以前内部定义了final char[ ] value用于存储字符串数据。jdk9时改为byte [ ]

String:代表不可变的字符序列。简称:不可变性。

当对字符串重新赋值时，需要重写指定内存区域赋值，不能使用原有的value进行赋值。当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值, 不能使用原有的value进行赋值。当调用String的replace()方法修改指定字符或字符串时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值。通过字面量的方式(区别于new)给一个字符串赋值，此时的字符串值声明在字符串常量池中。

字符串常量池中是不会存储相同内容的字符串的。 String的String Pool 是一一个固定大小的Hashtable,默认值大小长度是1009。如果放进String Pool的String非常多， 就会造成Hash冲突严重，从而导致链表会很长，而链表长了后直接会造成的影响就是当调用String. intern时性能会大幅下降。 使用==-XX : StringTableSize可设置StringTable==的长度 在jdk6中StringTable是固定的，就是1009的长度，所以如果常量池中的字符串过多就会导致效率下降很快。StringTableSize设置没有要求 在jdk7中，StringTable的长度默认值是60013 Jdk8开始，设置StringTable的长度的话，1009是可设置的最小值。

Demo1.1

public class StringTest1 { @Test public void test1() { string s1 = "abc";//字面量定义的方式，"abc"存储在字符串常量池中 string s2 = "abc"; S1 = "hello"; System.out.println(s1 == s2);//判断地址: true --> false System.out.println(s1);// System.out.println(s2);// }

Demo1.2

public class stringExer { string str = new String( original: "good"); char[] ch = {'t', 'e', 's', 't'}; public void change(String str, char ch[]) { str = "test ok"; ch[0] = 'b'; } public static void main(String[] args) { StringExer ex = new StringExer(); ex.change(ex.str, ex.ch); System.out.println(ex.str);//good System.out.println(ex.ch) ;//best } }

2，String的内存分配

在Java语言中有8种基本数据类型和–种比较特殊的类型String[属于引用类型]。这些类型为了使它们在运行过程中速度更快、更节省内存，都提供了一种常量池的概念。常量池就类似-一个Java系统级别提供的缓存。8种基本数据类型的常量池都是系统协调的，String类型的常量池比较特殊。它的主要使用方法有两种。 直接使用双引号声明出来的String对象会直接存储在常量池中。 比如: String info = “hello world”;如果不是用双引号声明的String对象， 可以使用string提供的 intern()方法。这个后面重点谈， Java 6及以前，字符串常量池存放在永久代。Java 7中Oracle 的工程师对字符串池的逻辑做了很大的改变，即将 字符串常量池的位置调整到Java堆内。 所有的字符串都保存在堆(Heap)中，和其他普通对象- -样，这样可以让你在进行调优应用时仅需要调整堆大小就可以了。字符串常量池概念原本使用得比较多，但是这个改动使得我们有足够的理由让我们重新考虑在Java 7中使用String. intern()。Java8元空间，字符串常量在堆

jdk 6 jdk 7 那么，StringTable为什么要调整？ 通过上述说明，我们得到原因如下： 1，permSize默认值较小，而且如此易引发永久代的垃圾回收频率，降低了性能

3，String的基本操作

Demo3.1

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(0bject param) {//line 6 String str = param. toString();//Line 7 System.out.println(str); }//Line 8 }

3，1 String的拼接操作

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

Demo3.2

public class stringTest5 { @Test public void test1(){ String s1 ="a" + "b" + "c";//等同于"abc string s2 = "abc"; //"abc"- -定是放在字符审常量池中，将此地址赋给s2 /* *最终.java编译成.class, 再执行.class String s1 = "abc"; * string s2 = "abc" */ System.out.println(s1 == s2); //true system.out.println(s1.equals(s2)); //true }

Demo3.3

@Test public void test(){ String s1 = "javaEE"; String s2 = "hadoop" ; String s3 = "javaEEhadoop" ; String s4 = "javaEE" + "hadoop" ;//编译期优化 //如果拼接符号的前后出现了变量，则相当于在堆空间中new string(),具体的内容为拼接的结果: javaEEhadoop String s5 = s1 + "hadoop" ; String s6 = "javaEE" + S2; String s7 = s1 + S2; System.out.println(s3 == s4);//true System.out.println(s3 == s5);//false System.out.println(s3 == s6);//false System.out.println(s3 == s7);//false System.out.println(s5 == s6);//false System.out.println(s5 == s7);//false System.out.println(s6 == s7);//false //intern():判断宇符串常量池中是否存在javaEEhadoop值，如果存在，则返回常量池中javaEEhadoop的地址; //如果字符串常量池中不存在javaEEhadoopI则在常量池中加载一份javaEhadoop,并返回次对象的地址。 String s8 = s6.intern(); System.out.println(s3 == s8);//true

3，2 字符串拼接的底层原理

Demo3.4

@Test public void test3(){ string S1 = "a"; string s2 = "b"; string S3 = "ab"; /* 如下的s1 + s2的执行细节: ③stringBuilder s = new StringBuilder(); ②s.append("a") ③s.append("b") ④s. tostring() --> 约等于new string( "ab") */ String S4=51+ s2;// System.out.println(s3 == s4);//false }

注： 1.宇符串拼接操作不- -定使用的是stringBuilder!如果拼接符号左右两边都是字符串常量或常量引用，则仍然使用编译期优化，即非stringBuilder的方式。 2.针对于final修饰类、方法、基本数据类型、引用数据类型的量的结构时，能使用Efinal的时候建议使用上。 Demo3.5

@Test public void test5(){ string s1 = "javaEEhadoop" ; string S2 = "javaEE"; string s3 = s2 + "hadoop" ; System.out. println(S1 == s3);//false final string s4 = "javaEE";//s4:常量 //常量引用 + 常量拼接 编译期优化。。。此时不是对象拼接常量！！！ String s5 = s4 + "hadoop" ; System.out.println(s1 == s5);//true ;

3，3 拼接和StringBuild的append()操作的效率对比

很显然，对于任意的一个demo，当执行次数越大，拼接的效率远低于StringBuild的append()，花费的时间比远超两三个数量级

体会执行效率:通过StringBuilder 的append()的方式添加字符串的效率要远高于使用string的字符串拼接方式!详情:① StringBuilder的append()的方式:自始至终中只创建过一个StringBuilder 的对象 使用string的字符串拼接方式:创建过多个stringBuilder和string的对象② 使用string的字符串拼接方式:内存中由于创建了较多的stringBuilder和string的对象，内存占用更大:

改进： 在实际开发中，如果基本确定要前前后后添加的字符串长度不高于某个限定值highlevel的情况下建议使用构造器实例化: stringBuilder s = new StringBuilder(highLevel);//等价于new char[highLevel]

4，String的intern()的使用

如果不是用双引号声明的String对象，可以使用String提供的intern方法: intern方法会从字符串常量池中查询当前字符串是否存在，若不存在就会将当前字符串放入常量池中。

比如: String myInfo = new String(“I love atguigu”) . intern() ;

也就是说，如果在任意字符串上调用String. intern方法，那么其返回结果所指向的那个类实例，必须和直接以常量形式出现的字符串实例完全相同。因此，下列表达式的值必定是true:

(“a” + “b” + “c”) . intern() == “abc”

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

5，通过面试题来更好的了解String

注：class文件中字节码指令ldc指令代表将变量放进常量池中

5，1 new String(“ab”) 会创建几个对象?

看字节码，就知道是两个。 一个对象是: new关键字在堆空间创建的 另一个对象是:字符串常量池中的对象。 字节码指令: ldc

5，2 new String(“a” ) + new String(“b”)呢?

对象1: new StringBuilder()对象2:new String(“a”)对象3:常量池中的"a"对象4:new String(“b”)对象5:常量池中的"b"

深入剖析: StringBuilder 的tostring():

对象6 : new string(“ab”)

5，3 intern()面试题

Demo5.1

public class StringIntern { public static void main(String[] args) { String s = new string("1"); //调用x.intern()就说将字面量放入常量池，如果字面量没有在常量池的情况下 s.intern();//调用此方法前，字符串常量池中不存在"1" String s2 = "1"; System.out.println(s == s2);//jdk6: false jdk7/8: false //理由 ： new string("1"); 创建了两个对象，先常量池中创建，再 堆中 String s3 = new string("1") + new string("1");//new String("11") s3.intern();//调用此方法前，字符串常量池中不存在"11" string s4 = "11"; /* 如何理解此时的(s3 == s4)//jdk6: false jdk7/8: true // 此时常量池中没有11 s3.intern()之后常量池才存放了一份指向s3的引用【jdk8】所以s4 == s3 jdk 6中 s3.intern(); 说明s3是通过StringBuilder调用的，最后new String("11")，有了新的地址 jdk 7/8中，此时的jdk致力于减少重复对象的产生 于是：s3.intern()之后，常量池在的“11”是指向堆空间中那个11对象的一个指针！！！ 所以，为了根据重复对象的原理，那么string s4 = "11";也是上句话的那个指针 */ System.out.println(s3 == s4);//jdk6: false jdk7/8: true } }

Demo5.2

public class StringInternExtend { public static void main(String[] args) { //stringIntern. java中练习的拓展: String s3 = new String("1") + new String("1");//new String("11") //执行完上一行代码以后，字符串常量池中，是"否存在"11"呢? 答案:不存在! ! string s4 =“11";//在字符串 常量池中生成对象"11” String s5 = s3. intern(); System.out.println(s3 == s4);//false System.out.println(s5 == s4);//true } }

总结： 总结String的intern()的使用:

jdk1.6中，将这个字符串对象尝试放入串池。【放copy对象】

如果串池中有，则并不会放入。返回已有的串池中的对象的地址如果没有，会把此对象复制一份，放入串池，并返回串池中的对象地址

Jdk1.7起，将这个字符串对象尝试放入串池。【放指针】

如果串池中有，则并不会放入。返回已有的串池中的对象的地址如果没有，则会把对象的引用地址复制一份，放入串池，并返回串池中的引用地址 Demo5.3 //复习demo public class StringExer2 { public static void main(String[] args) { string s1 = new string("ab");//执行完以后，会在字符串常量池中会生成"ab” 下述执行完以后，不会在字符串常量池中会生成"ab" //string s1 = new string("a") + new String("b"); s1.intern(); String s2 = "ab" ; System.out.println(s1 == s2);//false } }

6，intern的效率测试

使用intern()测试执行效率:空间使用上 结论:对于程序中大量存在的字符串，尤其其中存在很多重复字符串时，使用intern() 可以节省内存空间。

例如： 大的网站平台，需要内存中存储大量的字符串。比如社交网站，很多人都存储:北京市、海淀区等信息。这时候如果字符串都调用intern()方法，就会明显降低内存的大小。

7，StringTable的垃圾回收

Demo5.3

/* * String的垃圾回收: * -Xms15m -Xmx15m -XX: +PrintStringTableStatistics * -XX: +PrintGCDetails */ public class StringGCTest { public static void main(String[] args) { for (int j = 0; j < 100000; j++){ String.valueof(j).intern(); } } }

8，G1中的String的去重操作

背景:对许多Java应用(有大的也有小的)做的测试得出以下结果:

堆存活数据集合里面string对象占了25%堆存活数据集合里面重复的String对象有13.5%String对象的平均长度是45

许多大规模的Java应用的瓶颈在于内存，测试表明，在这些类型的应用里面，Java堆中存活的数据集合差不多25%是String对象。更进一步，这里面差不多一半String对象是重复的，重复的意思是说:string1.equals (string2) = true。堆上存在重复的String对象必然是一种内存的浪费。这个项目将在G1垃圾收集器中实现自动持续对重复的String对象进行去重，这样就能避免浪费内存。

实现：当垃圾收集器工作的时候，会访问堆上存活的对象。对每一个访问的对象都会检查是否是候选的要去重的String对象。如果是，把这个对象的一一个引用插入到队列中等待后续的处理。一个去重的线程在后台运行，处理这个队列。处理队列的-一个元素意味着从队列删除这个元素，然后尝试去重它引用的String对象。使用一个hashtable来记录所有的被String对象使用的不重复的char数组。当去重的时候，会查这个hashtable,来看堆上是否已经存在一个一模一样的char数组。如果存在，string对 象会被调整引用那个数组，释放对原来的数组的引用，最终会被垃圾收集器回收掉。如果查找失败，char数组会被插入到hashtable,这样以后的时候就可以共享这个数组了。 命令行选项UseStringDeduplication (bool) :开启String去重，默认是不开启的，需要手动开启。PrintStringDeduplicationStatistics (bool) :打印详细的去重统计信息StringDeduplicationAgeThreshold (uintx) :达到这个年龄的String对象被认为是去重的候选对象