`
Arron.li
  • 浏览: 136571 次
  • 性别: Icon_minigender_1
  • 来自: 深圳
社区版块
存档分类
最新评论

JAVA面试试题解惑系列(创建几个String对象)

    博客分类:
  • Java
阅读更多

作者:臧圩人(zangweiren)
网址:http://zangweiren.iteye.com


我们首先来看一段代码:

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的构造器:

public String(String original) {
	//other code ...
}


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

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


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

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

String str="abc";


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

String a="abc";
String b="abc";


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

String a="ab"+"cd";


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

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

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

对于第三个例子:

String a="ab"+"cd";


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

String a="abcd";


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

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

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


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

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)的“+”连接表达式,它所产生的新对象都不会被加入字符串池中,对此我们不再赘述。

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

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的值也是固定的,它在类被编译时就已经确定了。也就是说:

String s=A+B;


等同于:

String s="ab"+"cd";


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

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()方法,它的定义如下:

public native String intern();


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

我们来看这段代码:

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,这是一份不错的文件

    JAVA 面试题解惑系列之 String 对象创建机制 本文将深入探讨 JAVA 中 String 对象的创建机制,解答常见的面试题目,并探索 String 对象池的概念和机制。 一、String 对象的创建方式 在 JAVA 中,String 对象可以...

    JAVA面试题解惑系列合集

    .3 1.2 JAVA面试题解惑系列(二)——到底创建了几个String对象? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .8 1.3 JAVA面试题解惑系列(三)——变量(属性)的覆盖 . . . . . . . . . . . . ....

    臧圩人--JAVA面试题解惑系列合集.pdf

    **1.2 JAVA面试题解惑系列(二)——到底创建了几个String对象?** - **知识点**:探讨Java中String对象的创建机制,特别是常量池的概念和String对象的内存分配策略。了解字符串字面量与`new String()`的区别,以及...

    Java面试题解惑系列

    2、到底创建了几个String对象;3、变量(属性)的覆盖;4、final,finally,finalize;5.传了值还是传了引用;6.String杂谈;7.日期与时间的处理;8.基本类型总结;9.继承,多态,重载,重写;10.多线程;11.运算符...

    JAVA面试题解惑系列

    例如,"abc" + "def" 实际上会产生几个String对象?答案是可能会有两个,一个是临时的StringBuilder对象,另一个是最后的连接结果。 3. **变量(属性)的覆盖**: 在Java中,子类可以覆盖父类的方法,但不能覆盖...

    JAVA面试题解惑系列.doc

    《JAVA面试题解惑系列——类的初始化顺序》 在Java编程中,理解类的初始化顺序是面试中常见的考察点,因为它直接关系到程序的执行逻辑。本文将深入探讨类的初始化过程,以及在继承场景下如何理解这个过程。 首先,...

    JAVA面试题解惑系列.pdf

    ### Java面试题解惑系列——类的初始化顺序详解 #### 背景介绍 在Java面试过程中,关于类的初始化顺序的问题是常见的考察点之一。此类问题通常涉及到类的加载机制、静态变量与实例变量的区别、初始化块的作用及执行...

    经典JAVA面试题解惑系列合集

    ### 经典JAVA面试题解惑系列合集 #### 1. JAVA面试题解惑系列(一)——类的初始化顺序 在Java编程语言中,理解类的初始化顺序是非常重要的,尤其是在涉及继承的情况下。本节将详细介绍类初始化的规则,并通过实例...

    java面试解惑系列

    ### Java面试解惑系列:类的初始化顺序 在Java编程语言中,理解类的初始化顺序是非常重要的,尤其是在处理继承和复杂对象创建时。本篇文章将会深入解析类的初始化顺序,帮助读者更好地准备Java面试。 #### 类的...

    Java面试题详解,和一些基础知识的深入剖析,个人认为非常棒

    首先,我们来看“JAVA面试题解惑系列(二)——到底创建了几个String对象?”这个问题。在Java中,String是不可变的,这意味着一旦创建,其内容就不能改变。因此,每当对String进行操作,如拼接或赋值,实际上可能...

    JAVA面试题解惑系列(1-6).txt

    主要分为以下几个部分: ### 一、类的初始化顺序 #### 1. 类的静态初始化 - **静态变量声明**:在类定义中,首先会声明静态变量,如 `public static String staticField = "static";`。 - **静态代码块执行**:紧...

    IT学生解惑真经.pdf

    ### IT学生解惑真经之Java面试题:类的初始化顺序 #### 背景介绍 在IT领域,特别是对于正在学习或准备进入软件开发行业的学生们来说,掌握基础且重要的编程概念至关重要。Java作为一种广泛使用的编程语言,在求职...

Global site tag (gtag.js) - Google Analytics