- 浏览: 448779 次
- 性别:
- 来自: 深圳
文章分类
最新评论
-
g_man1990:
update config 不成功啊
build-helper-maven-plugin 配置多 source resource 文件 -
netwelfare:
文章很详细,就是太长了,读起来有点困难,倒不如写精练点,像这篇 ...
Java 基本类型 -
huyuancai1010:
function commitForm() {
var ...
加时间戳或者随机数去除js缓存 -
Smile__:
不过这个东西以前还真没研究过 。
hibernate.jdbc.fetch_size 和 hibernate.jdbc.batch_size -
Smile__:
想不到你也是北大青鸟的 。哈
hibernate.jdbc.fetch_size 和 hibernate.jdbc.batch_size
我们首先来看一段代码:
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 ... }
大家都知道,我们常用的创建一个类的实例(对象)的方法有以下两种:
- 使用new创建对象。
- 调用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",并且它被保存在字符串池里了。
现在问题又来了,是不是所有经过“+”连接后得到的字符串都会被添加到字符串池中呢?我们都知道“==”可以用来比较两个变量,它有以下两种情况:
- 如果比较的是两个基本类型(char,byte,short,int,long,float,double,boolean),则是判断它们的值是否相等。
- 如果表较的是两个对象变量,则是判断它们的引用是否指向同一个对象。
下面我们就用“==”来做几个测试。为了便于说明,我们把指向字符串池中已经存在的对象也视为该对象被加入了字符串池:
- 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 创建的对象 \"没加入\" 字符串池中");
- }
- }
- }
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 创建的对象 \"没加入\" 字符串池中"); } } }
运行结果如下:
- String a = "ab";
- String b = "cd";
- "ab"+"cd" 创建的对象 "加入了" 字符串池中
- a +"cd" 创建的对象 "没加入" 字符串池中
- "ab"+ b 创建的对象 "没加入" 字符串池中
- 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,它们不是同一个对象");
- }
- }
- }
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,它们不是同一个对象");
- }
- }
- }
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没被加入字符串池中,新建了对象");
- }
- }
- }
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没被加入字符串池中,新建了对象"); } } }
运行结果:
- 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")为什么是创建了两个对象这个问题就已经相当明了了。
发表评论
-
StringBuStringffer 和 StringBuilder 区别
2010-02-05 17:37 1422String 字符串常量 StringBuffer 字符串变量 ... -
Java timezone
2010-01-13 20:57 1715转自:行者买刀 获得java时间时,突然获得的时间不是当前 ... -
Javap
2010-01-04 10:07 3765javap是jdk自带的一个工具,可以反编译,也可以查看jav ... -
JAVA 主动调用与被动调用
2009-12-31 13:54 2325public class Test { stati ... -
Java解析XML文件的方法比较
2009-12-24 17:14 13671)DOM(JAXP Crimson解 ... -
Java 遍历二叉树
2009-12-18 17:13 2011Binary.java import java.util.S ... -
Java protected
2009-12-16 15:17 4773(1)除了在(2)中表 ... -
ConcurrentHashMap
2009-12-15 11:40 1874关键字: concurrenthashmap ... -
SimpleDateFormat 参数 Z
2009-12-11 17:20 1712import java.text.SimpleDate ... -
HashMap 详解
2009-12-04 14:30 1455Hashmap是一种非常常用的、应用广泛的数据类型,最近研究到 ... -
JAVA自动装箱与拆箱
2009-11-24 17:15 1659自动装箱与拆箱的功能事实上是编译器来帮您的忙,编译器在编译时期 ... -
String java
2009-11-24 16:29 1467众所周知,String是由字符组成的串,在程序中使用频率很高。 ... -
Java 动态绑定
2009-09-08 11:45 1525代码: public class Par ... -
JAVA虚拟机命令行参数
2009-08-18 15:51 2013一、运行class文件执行带main方法的class文件,命令 ... -
Collections.sort
2009-07-03 16:59 1716第一种方法:容器内要排序的类必须时下Comparable接口: ... -
java 多态 例子
2009-06-30 21:58 2706其实也就是两种绑定状态:动态绑定(也称后期绑定),静态绑定(也 ... -
Java 字节 字符 字符串
2009-06-23 10:07 6036String的length()方法和数组的length属性 S ... -
Java 运算符 详解
2009-06-23 09:59 2171有些运算符在JAVA语言中存在着,但是在实际开发中我们或许很少 ... -
Java 面试题 经典
2009-06-22 16:42 1699请下载见附件~~~ -
Java 基本类型
2009-06-22 16:39 32383基本类型,或者叫做内置类型,是JAVA中不同于类的特殊类型。它 ...
相关推荐
当我们创建一个 String 对象时,JAVA 虚拟机(JVM)首先会在字符串池中查找是否已经存在了该对象,如果存在,则不再创建新的对象,直接返回已存在对象的引用;如果不存在,则创建新的对象,并将其加入字符串池中。 ...
### 创建string对象过程的内存分配详解 #### 一、引言 在Java中,`String` 类是最常用的数据类型之一,用于表示不可变的字符序列。`String` 对象的创建涉及复杂的内存分配机制,特别是在Java虚拟机 (JVM) 的环境中...
` 这行代码会创建几个String对象。答案是两个。`"abc"`在Java中是一个字面量,它在运行时会被自动放入字符串池。`new String("abc")`则会创建一个新的String对象,因为它是通过new关键字调用了String类的构造函数。...
java面试的疑惑剪辑 博文链接:https://z-jq1015.iteye.com/blog/248599
对String创建几个对象代码详解,包括字符串相加,对象相加等等
接下来,我们通过几个例子来具体分析`String`对象的内存分配: 1. `String a = "abc"; String b = "abc";` 在这种情况下,"abc"首先会被放入常量池中。当创建`a`和`b`时,它们都指向常量池中的同一个"abc"对象,...
### string对象的操作详解 #### 一、string 类型简介及基本操作 在现代 C++ 编程中,`std::string` 是一个极其重要的类,它提供了丰富的接口用于字符串的处理,大大简化了字符串操作的复杂性。下面将详细介绍 `std...
当遇到new时,还会在内存(不是字符串常量池中,而是在堆里面)上创建一个新的String对象,存储该值,并将内存上的String对象引用地址返回。 String str = new String("xyz"); 产生了两个对象,一个是字符串常量池...
上图红色的这3个箭头,对于通过new产生一个字符串(”宜春”)时,会先去常量池中查找是否已经有了”宜春”对象,如果没有则在常量池中创建一个此字符串对象,然后堆中再创建一个常量池中此”宜春”对象的拷贝对象。...
本文将详细探讨这一转换过程,并通过几个具体的示例来帮助理解。 #### 一、基础知识 在深入讨论如何将列表转换为字符串数组之前,我们首先需要了解一些基本概念。 - **List**:`List`是Java集合框架的一部分,...
下面我们将详细讲解几个重要的`String`类的方法: 1. **构造方法**: - `String()`:创建一个空字符串。 - `String(char[] array)`:根据字符数组创建字符串。 - `String(String anotherString)`:复制已有字符...
为了更好地理解和使用String类,本文将从几个关键方面入手,探讨如何更加高效、合理地使用String对象。 #### 一、初始化String对象 **1.1 直接赋值** 最常见的初始化方式是通过直接赋值的方式创建String对象: ``...
我想所有 Java 程序员都曾被这个 new...以目前的情况来看,关于 new String(“xxx”) 创建对象个数的答案有 3 种: 有人说创建了 1 个对象; 有人说创建了 2 个对象; 有人说创建了 1 个或 2 个对象。 而出现多个答案
标题提到的“自己写了个string类”,意味着作者创建了一个类似于C++标准库中的`std::string`的自定义字符串类。这样的练习有助于深入理解字符串的内部工作原理、内存管理和对象操作。下面我们将详细探讨这个话题。 ...
在Java编程语言中,String类是一个非常基础且重要的部分,它是不可变的,也就是说一旦创建了一个String对象,就不能更改它的内容。然而,许多初学者在学习过程中可能会尝试自己创建一个类似的字符串类,以便更好地...
在这个自定义的`string`类中,主要涉及以下几个知识点: 1. **字符指针**:字符指针是C/C++语言中处理字符串的基本工具。它是一个指向字符的指针,可以用来指向字符串的首字符。例如,`char *str`可以用来声明一个...
这两种形式都是用来从原始字符串中截取一部分字符并创建一个新的`String`对象。 首先,让我们看第一种形式`substring(index)`。这个方法从指定的索引位置开始,一直到字符串末尾。在示例代码中,`stringOne....
创建了几个对象,为什么? 答案:创建了两个对象。"abc" 本身创建在常量池中,通过 new 又创建在堆中。String str = new String("abc"); 这一语句创建了两个对象:一个是常量池中的 "abc",另一个是堆中的 String ...
1. **线程安全**:由于String对象不可变,所以在多线程环境中,多个线程可以安全地共享同一个String对象,无需担心同步问题。这提高了程序的并发性能。 2. **缓存哈希码**:String对象经常用于HashMap等数据结构中...