String 创建几个对象问题（详解

Posted 2023-04-26

1
String a = new String("b");

创建两个对象

"b"在String pool池中，当创建对象时，堆中会拷贝String池中”b“作为一个对象b1，
然后建立一个新对象该对象的引用a指向b1；

所以创建两个对象。

2

String c="b";

"b"在String池中，c指向该对象；

3

String a="i"+"u"+"s0";

这相当于String a="ius0".当JVM执行到这一句时，就在String pool里找，如果String pool里没有这个字符串，就会产生一个对象（见java面试宝典174页）

如果String pool里有这些字符串就产生2个对象 原因：每做一个连接便会产生一个对象.

4

String a="b";

a=a+"b";//有两个对象，第一a是个对象 2 a+"b"为一个对象

这时 原来 a指向的对象就变为垃圾对象，但后面又被用到所以没被回收 和"b'进行连接成为bb

5

String a="b";

a=a+"c";//有两个对象，第一"c"是个对象 2 a+"c"为一个对象

此时a原来指向的对象成为垃圾对象，由jvm垃圾回收机制回收

6

String c;创建对象个数为 0;

初始化为null 参考技术A

Java详解【String】推荐你一个博客看

String类是被final所修饰的，因此String类对象不可变，也不可继承。这里要注意一个误区，字符串对象不可变，但字符串变量所指的值是可变的，即引用地址可变。String变量存储的是对String对象的引用，String对象里存储的才是字符串的值【注意区分对象和对象的引用】

String的两种赋值方式

※ 区分【String str="HW"】和【String str=new String("HW")】

（1）字面量赋值方式     eg：String str = "Hello"；

该种直接赋值的方法，JVM会去字符串常量池（String对象不可变）中寻找是否有equals("Hello")的String对象，如果有，就把该对象在字符串常量池中"Hello"的引用复制给字符串变量str，如若没有，就在堆中新建一个对象，同时把引用驻留在字符串常量池中，再把引用赋给字符串变量str。

用该方法创建字符串时，无论创建多少次，只要字符串的值(内容)相同，那么它们所指向的都是堆中的同一个对象。

该方法直接赋值给变量的字符串存放在常量池里

（2）new关键字创建新对象     eg：String str = new String("Hello")；

利用new来创建字符串时，无论字符串常量池中是否有与当前值相同的对象引用，都会在堆中新开辟一块内存，创建一个新的对象。

关于String s = new String("xyz"); 创建几个对象的问题

题目
String s = new String(“hello”)和String s = “hello”;的区别?

区别
String s = new String(“hello”)会创建2（1）个对象，String s = “hello”创建1（0）个对象。
注：当字符串常量池中有对象hello时括号内成立！

引入
==与equals()的区别：

==:比较引用类型比较的是地址值是否相同
equals:比较引用类型默认也是比较地址值是否相同，而String类重写了equals()方法，比较的是内容是否相同。
Demo
public class StringDemo2 {
public static void main(String[] args) {
String s1 = new String("hello");
String s2 = "hello";
System.out.println(s1 == s2);// false
System.out.println(s1.equals(s2));// true
}
}
**运行结果：**

> false
> true
1
2
3
4
5
6
7
8
9
10
11
12
内存图

代码详解
首先，通过main（）方法进栈。
然后再栈中定义一个对象s1,去堆中开辟一个内存空间，将内存空间的引用赋值给s1，“hello”是常量，然后去字符串常量池 查看是否有hello字符串对象，没有的话分配一个空间存放hello，并且将其空间地址存入堆中new出来的空间中。
在栈中定义一个对象s2，然后去字符串常量池中查看是否有”hello”字符串对象，有，直接把”hello”的地址赋值给s2.
即s1中存的是堆中分配的空间，堆中分配的空间中存的是字符串常量池中分配空间存放”hello”的空间的地址值。而s2中之间存的是字符串常量池中分配空间存放”hello”的空间的地址值。
由于s1与s2中存放的地址不同，所以输出false。因为，类String重写了equals()方法，它比较的是引用类型的 的值是否相等，所以输出true。即结果为false、true。
Demo1
public class StringDemo1 {
public static void main(String[] args) {
String s1 = new String("hello");
String s2 = new String("hello");
System.out.println(s1 == s2);// false
System.out.println(s1.equals(s2));// true

String s3 = new String("hello");
String s4 = "hello";
System.out.println(s3 == s4);// false
System.out.println(s3.equals(s4));// true

String s5 = "hello";
String s6 = "hello";
System.out.println(s5 == s6);// true
System.out.println(s5.equals(s6));// true
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

Demo1详解
s1~s6用equals()的比较不解释，都是比较的值，均为true。以下讲解==

s1、s2：二者均为new出来的，各自在堆中分配有空间，并各自将内存地址赋值给s1、s2。空间地址不同，==比较为false。但是各自在堆中空间中保存的值均为在字符串常量池中的同一个对象的地址。根据Demo处的图即解释不难理解。
s3、s4同上Demo出解释。
s5、s6都是在常量池中取值，二者都指向常量池中同一对象，其地址值相同，所以结果为true。
Demo2
public class StringDemo4 {
public static void main(String[] args) {
String s1 = "hello";
String s2 = "world";
String s3 = "helloworld";
System.out.println(s3 == s1 + s2);// false
System.out.println(s3.equals((s1 + s2)));// true
System.out.println(s3 == "hello" + "world");//true
System.out.println(s3.equals("hello" + "world"));// true
}
}
1
2
3
4
5
6
7
8
9
10
11
12

Demo2详解
equals()比较方法不解释，比较值，均相等，均为true。

s1与s2相加是先在字符串常量池中开一个空间，然后拼接，这个空间的地址就是s1与s2拼接后的地址。与s3的地址不同，所以输出为false。
s3与”hello”+”world”作比较，”hello”+”world”先拼接成”helloworld”,然后再去字符串常量池中找是否有”helloworld”,有，所以和s3共用一个字符串对象，则为true。
总结
String s = new String(“hello”)会创建2（1）个对象，String s = “hello”创建1（0）个对象。
注：当字符串常量池中有对象hello时括号内成立！
字符串如果是变量相加，先开空间，在拼接。
字符串如果是常量相加，是先加，然后在常量池找，如果有就直接返回，否则，就创建。
---------------------
作者：ZhouHuoCleverset
来源：CSDN
原文：https://blog.csdn.net/ZhouHuoCleverset/article/details/61935578
版权声明：本文为博主原创文章，转载请附上博文链接！