Java:String类型为什么可以直接赋值?使用new String赋值不可以吗?

首先明白一个事,java存在一个常量池,可以用来存储字符串常量。

字符串常量池(String类型为什么可以直接赋值?就和它有关)


String类是我们平常项目中使用频率非常高的一种对象类型,jvm为了提升性能和减少内存开销,避免字符的重复创建,其维护了一块特殊的内存空间,即字符串池,当需要使用字符串时,先去字符串池中查看该字符串是否已经存在,如果存在,则可以直接使用,如果不存在,初始化,并将该字符串放入字符创常量池中。

使用new String赋值不可以吗?可以,但是我们不开发中不建议用new String()的方式去创建字符串,原因如下:

两种创建方法的区别:

1. String str1= “abc”; 在编译期,JVM会去常量池来查找是否存在“abc”,如果不存在,就在常量池中开辟一个空间来存储“abc”;如果存在,就不用新开辟空间。然后在栈内存中开辟一个名字为str1的空间,来存储“abc”在常量池中的地址值。

2. String str2 = new String("abc") ;在编译阶段JVM先去常量池中查找是否存在“abc”,如果过不存在,则在常量池中开辟一个空间存储“abc”。在运行时期,通过String类的构造器在堆内存中new了一个空间,然后将String池中的“abc”复制一份存放到该堆空间中,在栈中开辟名字为str2的空间,存放堆中new出来的这个String对象的地址值。

也就是说,前者在初始化的时候可能创建了一个对象,也可能一个对象也没有创建;后者因为new关键字,至少在内存中创建了一个对象,也有可能是两个对象。
 

分别举例:

1.使用String直接赋值

String str = “abc”;可能创建一个或者不创建对象,如果”abc”在字符串池中不存在,会在java字符串池中创建一个String对象(”abc”),然后str指向这个内存地址,无论以后用这种方式创建多少个值为”abc”的字符串对象,始终只有一个内存地址被分配。==判断的是对象的内存地址,而equals判断的是对象内容。通过以下代码测试:

String str = "abc";
String str1 = "abc";
String str2 = "abc";
System.out.println(str==str1);//true
System.out.println(str==str2);//true

也就是str、str1、str2都是指向同一个内存地址。

2.使用new String()赋值

String str = new String(“abc”);至少会创建一个对象,也有可能创建两个。因为用到new关键字,肯定会在堆中创建一个String对象,如果字符池中已经存在”abc”,则不会在字符串池中创建一个String对象,如果不存在,则会在字符串常量池中也创建一个对象。

String str = new String("abc");
String str1 = new String("abc");
String str2 = new String("abc");
System.out.println(str==str1);//false
System.out.println(str==str2);//false

可以看出来,str、str1、str2指向的是不同的内存地址。

原因归纳:

上文可以归纳出:直接赋值产生1或0个对象,使用new String()赋值时产生2或1对象,赋值时先看字符串常量池,如果字符串常量池中没有,就在常量池中创建一个,如果有,前者直接引用,后者在堆内存中还需创建一个“abc”实例对象(此时引用变量指向的是堆内存中创建的实例对象,而不是常量池中的实例对象)。

String类被设计成不可变(immutable)类,所以它的所有对象都是不可变对象。例如:       

String str = “hello";

str = str + "world“;

当上文str指向了一个String对象(内容为“hello”),然后对str进行 “+” 操作,str原来指向的对象并没有变(依然存在在常量池中),而是str此时又指向了另外一个对象(“hello world”),原来的对象还在内存中。

由此可以看出,频繁的对String对象进行修改,会造成很大的内存开销。此时应该用StringBuffer或StringBuilder来代替String。

所以使用new String() 方式赋值更不适合,因为每一次创建对象都会调用构造器在堆中产生新的对象,性能低下且内存更加浪费。

额外说明(字很多,但这是知识的丰富):

使用String拼接字符串

项目中除了直接使用=赋值,也会用到字符串拼接,字符串拼接又分为变量拼接和已知字符串拼接。

String str = "abc";//在常量池中创建abc
String str1 = "abcd";//在常量池中创建abcd
String str2 = str+"d";//拼接字符串,此时会在堆中新建一个abcd的对象,因为str2编译之前是未知的
String str3 = "abc"+"d";//拼接之后str3还是abcd,所以还是会指向字符串常量池的内存地址
System.out.println(str1==str2);//false
System.out.println(str1==str3);//true

解答问题:为什么给str3赋值时不会在堆中创建一个对象,而给str2赋值时却会在堆中创建一个对象?

首先你要明白java编译器和运行期和String原理。

编译期:   是指把源码交给编译器编译成计算机可以执行的文件的过程。在Java中也就是把Java代码编成class文件的过程.编译期只是做了一些翻译功能,并没有把代码放在内存中运行起来,而只是把代码当成文本进行操作,比如检查错误。
 

运行期:  是把编译后的文件交给计算机执行.直到程序运行结束。所谓运行期就把在磁盘中的代码放到内存中执行起来。在Java中把磁盘中的代码放到内存中就是类加载过程。

比如通过String str = "aaa"赋值,字面量形式创建的字符串对象 "aaa" 存进了字符串常量池,而通过String str = String("bbb") 赋值,new 创建的 "bbb" 则是存进了堆中。这两种方式我们在代码编写时都经常使用,尤其是字面量的方式。然而这两种实现其实存在着一些性能和内存占用的差别。这一切都是源于JVM为了减少字符串对象的重复创建,其维护了一个特殊的内存,这段内存被成为字符串常量池或者字符串字面量池。

String工作原理:当代码中出现字面量形式创建字符串对象时,JVM首先会对这个字面量进行检查。如果字符串常量池中存在相同内容的字符串对象的引用,则将这个引用返回。如果没有则创建新的字符串对象,然后将这个引用放入字符串常量池,并返回该引用。

上面的概念比较笼统,其实就是啥意思呢?在编译时,如果碰到了String s = "hello"; 这样的赋值方式,就是字面量形式赋值,编译时就直接编译成 String s = "hello"; ,然后拿到内存中时就按照上述所说的直接赋值的那种方式去赋值,str3 = "abc" + "d"其实就等同于字面量赋值(即等同于str3 = "abcd")。但是,如果是str2这种赋值方式String str2 = str + "d"; ,虽然str在上面已经定义了,但是在编译时认为str仍是一个引用类型变量,所以此时就会把str2认为是以new String()方式来创建的,等来到内存中呢,就按照new String()这种方式去创建str2,自然堆内存中就会开辟空间,然后创建对象,接着再把空间的地址值返回给str2。所以str1和str2并没有指向同一个对象,地址值自然不同,这同时也解释了提出的问题。

下面在附上一个测试的例子,来更好的帮助你理解String和new String():

public class StringBy

{

    public static void main(String[] args){

    //情况一

    String a = "a2";

    String a2 = "a"+2;

    //在编译期值是确定的就是a2。只有编译期变量a与变量a2值相等他们才相等

    System.out.println(a==a2);

    //情况二

    String b = "b2";

    int bb = 2;

    String b2="b"+bb;

   //在编译期变量b2的值不是确定的,因为bb是变量,变量在运行期才能确定值.所以b与b2不等

    System.out.println(b==b2);

    //情况三

    String c="c2";

    final int cc=2;

    String c2="c"+cc;//在编译期c2的值是确定的,因为cc是个常量,值为2

    System.out.println(c==c2);

    //情况四

    String d="d2";

    final int dd=getZ();

    String d2="d"+dd;

    //在编译器d2的值是不确定的,因为dd还没有确定,因为dd的值是靠方法返回来的,但是方法的结果是在            
    //运行期才能得到的

    System.out.println(d==d2);//(对于两个对象,==的作用是比较他们的地址。)

    }

    public static int getZ(){

        return 2;

    }

}

参考链接:

https://www.cnblogs.com/lgg20/p/12521117.html

https://blog.csdn.net/weixin_41098980/article/details/80060200

https://jingyan.baidu.com/article/17bd8e521583f985ab2bb88a.html

对于为什么 const std::string& 类型参数可以给 std::string 类型参数赋值,而 const std::string 类型参数不可以给 std::string 类型参数赋值的原因,主要涉及到两个方面的区别:内存表示方式和语义含义。 1. 内存表示方式: - const std::string& 类型参数是一个常量引用,它在内存中存储的是一个指向 std::string 对象的地址。它不会占用额外的内存空间,只是作为一个引用来访问已存在的 std::string 对象。 - const std::string 类型参数是一个常量对象,它在内存中直接存储 std::string 类型的对象,占用自己的内存空间。 2. 语义含义: - const std::string& 类型参数表示一个对 std::string 对象的只读引用。它保证了被引用对象的值不会被修改,并提供了一种高效传递方式,避免了不必要的拷贝。 - const std::string 类型参数表示一个不可修改的 std::string 对象。它是一个独立的常量对象,其值在定义时已确定,并且不能被修改。 因此,当将 const std::string& 类型参数赋给 std::string 类型参数时,编译器可以自动进行类型转换和赋值操作,因为 const std::string& 类型参数本身就是对一个 std::string 对象的引用。这样做不会引入额外的内存开销,并且通过引用传递可以避免数据的拷贝。 而将 const std::string 类型参数赋给 std::string 类型参数时,由于它们是不同的类型,无法直接进行赋值操作。因为 const std::string 类型参数是一个独立的常量对象,而不是对某个 std::string 对象的引用。 综上所述,const std::string& 类型参数和 const std::string 类型参数在内存表示方式和语义含义上有所区别,导致了对 std::string 类型参数赋值时的行为不同。const std::string& 类型参数可以直接赋值给 std::string 类型参数,而 const std::string 类型参数不能直接赋值给 std::string 类型参数。
评论 13
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值