`

创建了几个 string 对象

    博客分类:
  • Java
阅读更多

我们首先来看一段代码:

Java代码 复制代码
  1. String str=new String("abc");  
String str=new String("abc");


紧接着这段代码之后的往往是这个问题,那就是这行代码究竟创建了几个String对象呢?相信大家对这道题并不陌生,答案也是众所周知的,2个。接下来我们就从这道题展开,一起回顾一下与创建String对象相关的一些JAVA知识。

我们可以把上面这行代码分成String str、=、"abc"和new String()四部分来看待。String str只是定义了一个名为str的String类型的变量,因此它并没有创建对象;=是对变量str进行初始化,将某个对象的引用(或者叫句柄)赋值给它,显然也没有创建对象;现在只剩下new String("abc")了。那么,new String("abc")为什么又能被看成"abc"和new String()呢?我们来看一下被我们调用了的String的构造器:

Java代码 复制代码
  1. public String(String original) {   
  2.     //other code ...   
  3. }  
public String(String original) {
	//other code ...
}


大家都知道,我们常用的创建一个类的实例(对象)的方法有以下两种:

  1. 使用new创建对象。
  2. 调用Class类的newInstance方法,利用反射机制创建对象。


我们正是使用new调用了String类的上面那个构造器方法创建了一个对象,并将它的引用赋值给了str变量。同时我们注意到,被调用的构造器方法接受的参数也是一个String对象,这个对象正是"abc"。由此我们又要引入另外一种创建String对象的方式的讨论——引号内包含文本。

这种方式是String特有的,并且它与new的方式存在很大区别。

Java代码 复制代码
  1. String str="abc";  
String str="abc";


毫无疑问,这行代码创建了一个String对象。

Java代码 复制代码
  1. String a="abc";   
  2. String b="abc";  
String a="abc";
String b="abc";


那这里呢?答案还是一个。

Java代码 复制代码
  1. String a="ab"+"cd";  
String a="ab"+"cd";


再看看这里呢?答案仍是一个。有点奇怪吗?说到这里,我们就需要引入对字符串池相关知识的回顾了。

在JAVA虚拟机(JVM)中存在着一个字符串池,其中保存着很多String对象,并且可以被共享使用,因此它提高了效率。由于String类是final的,它的值一经创建就不可改变,因此我们不用担心String对象共享而带来程序的混乱。字符串池由String类维护,我们可以调用intern()方法来访问字符串池。

我们再回头看看String a="abc";,这行代码被执行的时候,JAVA虚拟机首先在字符串池中查找是否已经存在了值为"abc"的这么一个对象,它的判断依据是String类equals(Object obj)方法的返回值。如果有,则不再创建新的对象,直接返回已存在对象的引用;如果没有,则先创建这个对象,然后把它加入到字符串池中,再将它的引用返回。因此,我们不难理解前面三个例子中头两个例子为什么是这个答案了。

对于第三个例子:

Java代码 复制代码
  1. String a="ab"+"cd";  
String a="ab"+"cd";


由于常量的值在编译的时候就被确定了。在这里,"ab"和"cd"都是常量,因此变量a的值在编译时就可以确定。这行代码编译后的效果等同于:

Java代码 复制代码
  1. String a="abcd";  
String a="abcd";


因此这里只创建了一个对象"abcd",并且它被保存在字符串池里了。

现在问题又来了,是不是所有经过“+”连接后得到的字符串都会被添加到字符串池中呢?我们都知道“==”可以用来比较两个变量,它有以下两种情况:

  1. 如果比较的是两个基本类型(char,byte,short,int,long,float,double,boolean),则是判断它们的值是否相等。
  2. 如果表较的是两个对象变量,则是判断它们的引用是否指向同一个对象。


下面我们就用“==”来做几个测试。为了便于说明,我们把指向字符串池中已经存在的对象也视为该对象被加入了字符串池:

Java代码 复制代码
  1. public class StringTest {   
  2.     public static void main(String[] args) {   
  3.         String a = "ab";// 创建了一个对象,并加入字符串池中   
  4.         System.out.println("String a = \"ab\";");   
  5.         String b = "cd";// 创建了一个对象,并加入字符串池中   
  6.         System.out.println("String b = \"cd\";");   
  7.         String c = "abcd";// 创建了一个对象,并加入字符串池中   
  8.   
  9.         String d = "ab" + "cd";   
  10.         // 如果d和c指向了同一个对象,则说明d也被加入了字符串池   
  11.         if (d == c) {   
  12.             System.out.println("\"ab\"+\"cd\" 创建的对象 \"加入了\" 字符串池中");   
  13.         }   
  14.         // 如果d和c没有指向了同一个对象,则说明d没有被加入字符串池   
  15.         else {   
  16.             System.out.println("\"ab\"+\"cd\" 创建的对象 \"没加入\" 字符串池中");   
  17.         }   
  18.   
  19.         String e = a + "cd";   
  20.         // 如果e和c指向了同一个对象,则说明e也被加入了字符串池   
  21.         if (e == c) {   
  22.             System.out.println(" a  +\"cd\" 创建的对象 \"加入了\" 字符串池中");   
  23.         }   
  24.         // 如果e和c没有指向了同一个对象,则说明e没有被加入字符串池   
  25.         else {   
  26.             System.out.println(" a  +\"cd\" 创建的对象 \"没加入\" 字符串池中");   
  27.         }   
  28.   
  29.         String f = "ab" + b;   
  30.         // 如果f和c指向了同一个对象,则说明f也被加入了字符串池   
  31.         if (f == c) {   
  32.             System.out.println("\"ab\"+ b   创建的对象 \"加入了\" 字符串池中");   
  33.         }   
  34.         // 如果f和c没有指向了同一个对象,则说明f没有被加入字符串池   
  35.         else {   
  36.             System.out.println("\"ab\"+ b   创建的对象 \"没加入\" 字符串池中");   
  37.         }   
  38.   
  39.         String g = a + b;   
  40.         // 如果g和c指向了同一个对象,则说明g也被加入了字符串池   
  41.         if (g == c) {   
  42.             System.out.println(" a  + b   创建的对象 \"加入了\" 字符串池中");   
  43.         }   
  44.         // 如果g和c没有指向了同一个对象,则说明g没有被加入字符串池   
  45.         else {   
  46.             System.out.println(" a  + b   创建的对象 \"没加入\" 字符串池中");   
  47.         }   
  48.     }   
  49. }  
public class StringTest {
	public static void main(String[] args) {
		String a = "ab";// 创建了一个对象,并加入字符串池中
		System.out.println("String a = \"ab\";");
		String b = "cd";// 创建了一个对象,并加入字符串池中
		System.out.println("String b = \"cd\";");
		String c = "abcd";// 创建了一个对象,并加入字符串池中

		String d = "ab" + "cd";
		// 如果d和c指向了同一个对象,则说明d也被加入了字符串池
		if (d == c) {
			System.out.println("\"ab\"+\"cd\" 创建的对象 \"加入了\" 字符串池中");
		}
		// 如果d和c没有指向了同一个对象,则说明d没有被加入字符串池
		else {
			System.out.println("\"ab\"+\"cd\" 创建的对象 \"没加入\" 字符串池中");
		}

		String e = a + "cd";
		// 如果e和c指向了同一个对象,则说明e也被加入了字符串池
		if (e == c) {
			System.out.println(" a  +\"cd\" 创建的对象 \"加入了\" 字符串池中");
		}
		// 如果e和c没有指向了同一个对象,则说明e没有被加入字符串池
		else {
			System.out.println(" a  +\"cd\" 创建的对象 \"没加入\" 字符串池中");
		}

		String f = "ab" + b;
		// 如果f和c指向了同一个对象,则说明f也被加入了字符串池
		if (f == c) {
			System.out.println("\"ab\"+ b   创建的对象 \"加入了\" 字符串池中");
		}
		// 如果f和c没有指向了同一个对象,则说明f没有被加入字符串池
		else {
			System.out.println("\"ab\"+ b   创建的对象 \"没加入\" 字符串池中");
		}

		String g = a + b;
		// 如果g和c指向了同一个对象,则说明g也被加入了字符串池
		if (g == c) {
			System.out.println(" a  + b   创建的对象 \"加入了\" 字符串池中");
		}
		// 如果g和c没有指向了同一个对象,则说明g没有被加入字符串池
		else {
			System.out.println(" a  + b   创建的对象 \"没加入\" 字符串池中");
		}
	}
}


运行结果如下:

  1. String a = "ab";
  2. String b = "cd";
  3. "ab"+"cd" 创建的对象 "加入了" 字符串池中
  4. a  +"cd" 创建的对象 "没加入" 字符串池中
  5. "ab"+ b   创建的对象 "没加入" 字符串池中
  6. a  + b   创建的对象 "没加入" 字符串池中


从上面的结果中我们不难看出,只有使用引号包含文本的方式创建的String对象之间使用“+”连接产生的新对象才会被加入字符串池中。对于所有包含new方式新建对象(包括null)的“+”连接表达式,它所产生的新对象都不会被加入字符串池中,对此我们不再赘述。

但是有一种情况需要引起我们的注意。请看下面的代码:

Java代码 复制代码
  1. public class StringStaticTest {   
  2.     // 常量A   
  3.     public static final String A = "ab";   
  4.   
  5.     // 常量B   
  6.     public static final String B = "cd";   
  7.   
  8.     public static void main(String[] args) {   
  9.         // 将两个常量用+连接对s进行初始化   
  10.         String s = A + B;   
  11.         String t = "abcd";   
  12.         if (s == t) {   
  13.             System.out.println("s等于t,它们是同一个对象");   
  14.         } else {   
  15.             System.out.println("s不等于t,它们不是同一个对象");   
  16.         }   
  17.     }   
  18. }  
public class StringStaticTest {
	// 常量A
	public static final String A = "ab";

	// 常量B
	public static final String B = "cd";

	public static void main(String[] args) {
		// 将两个常量用+连接对s进行初始化
		String s = A + B;
		String t = "abcd";
		if (s == t) {
			System.out.println("s等于t,它们是同一个对象");
		} else {
			System.out.println("s不等于t,它们不是同一个对象");
		}
	}
}


这段代码的运行结果如下:

  • s等于t,它们是同一个对象


这又是为什么呢?原因是这样的,对于常量来讲,它的值是固定的,因此在编译期就能被确定了,而变量的值只有到运行时才能被确定,因为这个变量可以被不同的方法调用,从而可能引起值的改变。在上面的例子中,A和B都是常量,值是固定的,因此s的值也是固定的,它在类被编译时就已经确定了。也就是说:

Java代码 复制代码
  1. String s=A+B;  
String s=A+B;


等同于:

Java代码 复制代码
  1. String s="ab"+"cd";  
String s="ab"+"cd";


我对上面的例子稍加改变看看会出现什么情况:

Java代码 复制代码
  1. public class StringStaticTest {   
  2.     // 常量A   
  3.     public static final String A;   
  4.   
  5.     // 常量B   
  6.     public static final String B;   
  7.   
  8.     static {   
  9.         A = "ab";   
  10.         B = "cd";   
  11.     }   
  12.   
  13.     public static void main(String[] args) {   
  14.         // 将两个常量用+连接对s进行初始化   
  15.         String s = A + B;   
  16.         String t = "abcd";   
  17.         if (s == t) {   
  18.             System.out.println("s等于t,它们是同一个对象");   
  19.         } else {   
  20.             System.out.println("s不等于t,它们不是同一个对象");   
  21.         }   
  22.     }   
  23. }  
public class StringStaticTest {
	// 常量A
	public static final String A;

	// 常量B
	public static final String B;

	static {
		A = "ab";
		B = "cd";
	}

	public static void main(String[] args) {
		// 将两个常量用+连接对s进行初始化
		String s = A + B;
		String t = "abcd";
		if (s == t) {
			System.out.println("s等于t,它们是同一个对象");
		} else {
			System.out.println("s不等于t,它们不是同一个对象");
		}
	}
}


它的运行结果是这样:

  • s不等于t,它们不是同一个对象


只是做了一点改动,结果就和刚刚的例子恰好相反。我们再来分析一下。A和B虽然被定义为常量(只能被赋值一次),但是它们都没有马上被赋值。在运算出s的值之前,他们何时被赋值,以及被赋予什么样的值,都是个变数。因此A和B在被赋值之前,性质类似于一个变量。那么s就不能在编译期被确定,而只能在运行时被创建了。

由于字符串池中对象的共享能够带来效率的提高,因此我们提倡大家用引号包含文本的方式来创建String对象,实际上这也是我们在编程中常采用的。

接下来我们再来看看intern()方法,它的定义如下:

Java代码 复制代码
  1. public native String intern();  
public native String intern();


这是一个本地方法。在调用这个方法时,JAVA虚拟机首先检查字符串池中是否已经存在与该对象值相等对象存在,如果有则返回字符串池中对象的引用;如果没有,则先在字符串池中创建一个相同值的String对象,然后再将它的引用返回。

我们来看这段代码:

Java代码 复制代码
  1. public class StringInternTest {   
  2.     public static void main(String[] args) {   
  3.         // 使用char数组来初始化a,避免在a被创建之前字符串池中已经存在了值为"abcd"的对象   
  4.         String a = new String(new char[] { 'a''b''c''d' });   
  5.         String b = a.intern();   
  6.         if (b == a) {   
  7.             System.out.println("b被加入了字符串池中,没有新建对象");   
  8.         } else {   
  9.             System.out.println("b没被加入字符串池中,新建了对象");   
  10.         }   
  11.     }   
  12. }  
public class StringInternTest {
	public static void main(String[] args) {
		// 使用char数组来初始化a,避免在a被创建之前字符串池中已经存在了值为"abcd"的对象
		String a = new String(new char[] { 'a', 'b', 'c', 'd' });
		String b = a.intern();
		if (b == a) {
			System.out.println("b被加入了字符串池中,没有新建对象");
		} else {
			System.out.println("b没被加入字符串池中,新建了对象");
		}
	}
}


运行结果:

  1. b没被加入字符串池中,新建了对象


如果String类的intern()方法在没有找到相同值的对象时,是把当前对象加入字符串池中,然后返回它的引用的话,那么b和a指向的就是同一个对象;否则b指向的对象就是JAVA虚拟机在字符串池中新建的,只是它的值与a相同罢了。上面这段代码的运行结果恰恰印证了这一点。

最后我们再来说说String对象在JAVA虚拟机(JVM)中的存储,以及字符串池与堆(heap)和栈(stack)的关系。我们首先回顾一下堆和栈的区别:

  • 栈(stack):主要保存基本类型(或者叫内置类型)(char、byte、short、int、long、float、double、boolean)和对象的引用,数据可以共享,速度仅次于寄存器(register),快于堆。
  • 堆(heap):用于存储对象。


我们查看String类的源码就会发现,它有一个value属性,保存着String对象的值,类型是char[],这也正说明了字符串就是字符的序列。

当执行String a="abc";时,JAVA虚拟机会在栈中创建三个char型的值'a'、'b'和'c',然后在堆中创建一个String对象,它的值(value)是刚才在栈中创建的三个char型值组成的数组{'a','b','c'},最后这个新创建的String对象会被添加到字符串池中。如果我们接着执行String b=new String("abc");代码,由于"abc"已经被创建并保存于字符串池中,因此JAVA虚拟机只会在堆中新创建一个String对象,但是它的值(value)是共享前一行代码执行时在栈中创建的三个char型值值'a'、'b'和'c'。

说到这里,我们对于篇首提出的String str=new String("abc")为什么是创建了两个对象这个问题就已经相当明了了。

分享到:
评论

相关推荐

    JAVA面试题解惑系列(二)——到底创建了几个String对象-JAVA程序员JAVA工程师面试必看.pdf,这是一份不错的文件

    当我们创建一个 String 对象时,JAVA 虚拟机(JVM)首先会在字符串池中查找是否已经存在了该对象,如果存在,则不再创建新的对象,直接返回已存在对象的引用;如果不存在,则创建新的对象,并将其加入字符串池中。 ...

    创建string对象过程的内存分配:

    ### 创建string对象过程的内存分配详解 #### 一、引言 在Java中,`String` 类是最常用的数据类型之一,用于表示不可变的字符序列。`String` 对象的创建涉及复杂的内存分配机制,特别是在Java虚拟机 (JVM) 的环境中...

    关于java的一个有趣的问题

    ` 这行代码会创建几个String对象。答案是两个。`"abc"`在Java中是一个字面量,它在运行时会被自动放入字符串池。`new String("abc")`则会创建一个新的String对象,因为它是通过new关键字调用了String类的构造函数。...

    new String(\"abc\")创建几个对象的解释

    java面试的疑惑剪辑 博文链接:https://z-jq1015.iteye.com/blog/248599

    String对象详解(附代码)

    对String创建几个对象代码详解,包括字符串相加,对象相加等等

    String对象的内存分析

    接下来,我们通过几个例子来具体分析`String`对象的内存分配: 1. `String a = "abc"; String b = "abc";` 在这种情况下,"abc"首先会被放入常量池中。当创建`a`和`b`时,它们都指向常量池中的同一个"abc"对象,...

    string对象的操作pdf

    ### string对象的操作详解 #### 一、string 类型简介及基本操作 在现代 C++ 编程中,`std::string` 是一个极其重要的类,它提供了丰富的接口用于字符串的处理,大大简化了字符串操作的复杂性。下面将详细介绍 `std...

    JAVA面试题String产生了几个对象

    当遇到new时,还会在内存(不是字符串常量池中,而是在堆里面)上创建一个新的String对象,存储该值,并将内存上的String对象引用地址返回。 String str = new String("xyz"); 产生了两个对象,一个是字符串常量池...

    String s = new String(” a “) 到底产生几个对象?

    上图红色的这3个箭头,对于通过new产生一个字符串(”宜春”)时,会先去常量池中查找是否已经有了”宜春”对象,如果没有则在常量池中创建一个此字符串对象,然后堆中再创建一个常量池中此”宜春”对象的拷贝对象。...

    list转换成string数组

    本文将详细探讨这一转换过程,并通过几个具体的示例来帮助理解。 #### 一、基础知识 在深入讨论如何将列表转换为字符串数组之前,我们首先需要了解一些基本概念。 - **List**:`List`是Java集合框架的一部分,...

    JAVA【第5章:面向对象基础】_String类的常用方法.rar

    下面我们将详细讲解几个重要的`String`类的方法: 1. **构造方法**: - `String()`:创建一个空字符串。 - `String(char[] array)`:根据字符数组创建字符串。 - `String(String anotherString)`:复制已有字符...

    正确使用String类的几点注意

    为了更好地理解和使用String类,本文将从几个关键方面入手,探讨如何更加高效、合理地使用String对象。 #### 一、初始化String对象 **1.1 直接赋值** 最常见的初始化方式是通过直接赋值的方式创建String对象: ``...

    别再问我 new 字符串创建了几个对象了!我来证明给你看!

    我想所有 Java 程序员都曾被这个 new...以目前的情况来看,关于 new String(“xxx”) 创建对象个数的答案有 3 种: 有人说创建了 1 个对象; 有人说创建了 2 个对象; 有人说创建了 1 个或 2 个对象。 而出现多个答案

    自己写了个string类

    标题提到的“自己写了个string类”,意味着作者创建了一个类似于C++标准库中的`std::string`的自定义字符串类。这样的练习有助于深入理解字符串的内部工作原理、内存管理和对象操作。下面我们将详细探讨这个话题。 ...

    java自制string类例程

    在Java编程语言中,String类是一个非常基础且重要的部分,它是不可变的,也就是说一旦创建了一个String对象,就不能更改它的内容。然而,许多初学者在学习过程中可能会尝试自己创建一个类似的字符串类,以便更好地...

    使用字符指针实现的一个简单string类

    在这个自定义的`string`类中,主要涉及以下几个知识点: 1. **字符指针**:字符指针是C/C++语言中处理字符串的基本工具。它是一个指向字符的指针,可以用来指向字符串的首字符。例如,`char *str`可以用来声明一个...

    Arduino项目开发 Strings_StringSubstring_StringSubstring.pdf

    这两种形式都是用来从原始字符串中截取一部分字符并创建一个新的`String`对象。 首先,让我们看第一种形式`substring(index)`。这个方法从指定的索引位置开始,一直到字符串末尾。在示例代码中,`stringOne....

    10个Java经典的String面试题

    创建了几个对象,为什么? 答案:创建了两个对象。"abc" 本身创建在常量池中,通过 new 又创建在堆中。String str = new String("abc"); 这一语句创建了两个对象:一个是常量池中的 "abc",另一个是堆中的 String ...

    Java 中的 String对象为什么是不可变的

    1. **线程安全**:由于String对象不可变,所以在多线程环境中,多个线程可以安全地共享同一个String对象,无需担心同步问题。这提高了程序的并发性能。 2. **缓存哈希码**:String对象经常用于HashMap等数据结构中...

Global site tag (gtag.js) - Google Analytics