八 8.1 --- String内容浅析

最新推荐文章于 2024-11-06 16:54:26 发布

ManJustDoneIt

最新推荐文章于 2024-11-06 16:54:26 发布

阅读量132

点赞数

分类专栏： JVM_Study

本文链接：https://blog.csdn.net/weixin_41628546/article/details/107119075

版权

JVM_Study 专栏收录该内容

24 篇文章 0 订阅

订阅专栏

八 8.1 — String内容浅析

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

八 8.1 --- String内容浅析

八 8.1 --- String内容浅析
1，String的基本特性
2，String的内存分配
3，String的基本操作
4，String的intern()的使用
5，通过面试题来更好的了解String
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对象被认为是去重的候选对象