`

java String 以及字符串直接量 与 字符串驻留池 ...

 
阅读更多

字符串 (String) 是 java 编程语言中的核心类之一,在我们平常时候使用也比较很普遍,应用广泛。
但你是否知道什么是字符串直接量,知不知道有个字符串驻留池,字符串的驻留池可以用来缓存字符串直接量。

什么是直接量?
直接量是指:在程序中,通过源代码直接指定的值。
eg:
int personId = 8080 ;
String name = "fancy" ;

对于 java 中的字符串直接量,JVM 会使用一个字符串驻留池来缓存它们。一般情况下,字符串驻留池中的字符串对象不会被 GC (Garbage Collection,垃圾回收) 所回收,
当再次使用字符串驻留池中已有的字符串对象时候,无需再次创建它,而直接使它的引用变量指向字符串驻留池中已有的字符串对象。

String 基础:

String 类代表字符串。字符串是常量,它们的值在创建之后是不能再被更改的。在 java 中除了 synchronized之外,不可变的类也是线程安全的,
因此,String 类本身也是线程安全的。String 类的实例对象其实是可以被共享的。

示例代码:

1
2        String name = "fancy";                  // @1
3        String nick    = "fancydeepin";  // @2
4        name = nick;
5        System.out.println(name);    // export:fancydeepin
6

结果输出 :fancydeepin

这是怎么回事?不是说 String 是不可变的字符串吗?怎么这里又变了?
是这样的,在这里 name 只是一个引用类型变量,并不是一个 String 对象,@1中创建了一个 "fancy" 的字符串对象,
@2中创建了一个 "fancydeepin" 的字符串对象,name 引用 (就像一个指针) 刚开始是指向 "fancy" 对象,而后,name 又重新指向 "fancydeepin" 对象,
在示例代码中,整个过程只创建了两个 String 对象 (不知道我这样说你能不能理解,为什么是只创建了两个 String 对象?而不是 1个、3个...  @3),
一个是 "fancy" 对象,另外一个是 "fancydeepin" 对象。而这两个对象被创建出来后并没有被改变过,之所以程序会输出 fancydeepin,完全只是因为
name 引用所指向的对象发生了改变。

如果你是本着认真的态度看着我的贴子,细心的你,是否会留意到:
当 name 引用重新指向另外一个对象的时候,那 name 之前引用的对象 ( "fancy" 对象 ) JVM 在底层会怎么处理它呢?是会立即来回收它来释放系统资源吗?
答案是否定的。虽然这时候程序再也不访问 "fancy" 这个对象,但 JVM 还是不会来回收它,它将在程序运行期间久驻内存,为什么会这样呢?
再往下说就扯到 java 的内存管理机制了,这里点到即止。在这里你可以简单的将它理解成 "fancy" 对象被缓存了起来 ( 实际上也是因为被缓存了 )。

字符串驻留池
当比较两个 String 对象时候,是应该用 "==" 呢?还是应该选择 equals 呢?相信绝大部分人绝大多时候使用的都是选择用 equals 方法。
"==" 和 equals 的用法相信大家都很熟悉了,"==" 比较的是两个对象的哈希码值是否相等,而 equals 比较的是对象的内容是否一样。
而绝大部分时候我们比较两个 String 对象的时候只是想比较它们的内容是否相等,这样看来,只能选 equals 了,但真的是这样吗?
答案是否定的。你一样也可以用 "==" 来完成这样的一件事情,而且 "==" 的效率无论如何都是要比使用 equals 的效率要高的,但前提是,
需要使用字符串的驻留池,才能使用 "==" 来替代 equals 作比较。
String 里面有个方法叫 intern(),执行效率很高,但也许你还不曾用过,下面是摘自API中 intern() 方法的描述:

“当调用 intern 方法时,如果池已经包含一个等于此 String 对象的字符串(用 equals(Object) 方法确定),则返回池中的字符串。
否则,将此 String 对象添加到池中,并返回此 String 对象的引用。 它遵循以下规则:
对于任意两个字符串 s 和 t,当且仅当 s.equals(t) 为 true 时,s.intern() == t.intern() 才为 true。 ”

示例代码:

 1
 2             String name = new String("fancy");
 3           
 4        if(name == "fancy") {    // false
 5            System.out.println("equals 1");
 6        }else {
 7            System.out.println("not equals 1");    // Be printed
 8        }
 9       
10        name = name.intern();    // 将字符串添加到驻留池
11       
12        if(name == "fancy") {    // true
13            System.out.println("equals 2");        // Be printed
14        }else {
15            System.out.println("not equals 2");
16        }
17

输出结果:

1
2not equals 1
3equals 2
4
 


由上面的示例代码可以看到,字符串驻留池的使用是非常简单的,池中的对象可以被共享,只要你将字符串添加到池中,就能够直接使用
"==" 来比较两个对象,而不是只能使用 equals 来作比较。将字符串添加到驻留池来使用 "==" 作比较的方式要比直接使用 equals 效率要高些。

再论 String、StringBuffer 和 StringBuilder

由 synchronized 修饰的方法可以保证方法的线程安全,但是会降低该方法的执行效率;

翻开 API,很容易就能知道:StringBuffer 是线程安全的可变字符序列,StringBuilder 是一个可变的字符序列,是线程不安全的;
网上说的所谓的使用 StringBuffer 的效率更高更好,这已经不合时宜,这是 java 1.5 之前的版本的说法,早过时了现在!!
现在是反过来了,由于 StringBuilder 不是线程安全的,StringBuilder 效率会比 StringBuffer 效率更高一些。

你可以不相信我说的,但你总该相信程序跑出来的结果吧,下面是示例代码:

 1
 2        StringBuffer  buffer  = new StringBuffer();
 3        StringBuilder builder = new StringBuilder();
 4        int COUNT = 10;       // 测试 COUNT 趟
 5        final int N = 100000; // 每趟操作 N 次
 6        double beginTime, costTime; // 每趟开始时间和耗费时间
 7        double bufferTotalTime = 0.0D, buliderTotalTime = 0.0D; // StringBuffer 和 StringBuilder 测试 COUNT 趟的总耗时
 8        while(COUNT -- > -1) {
 9            // 也可以测试每趟都创建一个新的对象,这样 StringBuilder 效率比 StringBuffer 的效率变得更明显了
10            /**
11            StringBuffer  buffer  = new StringBuffer();
12            StringBuilder builder = new StringBuilder();
13            */
14            System.out.println("----------------------------------<" + (COUNT + 1) + ">");
15            beginTime = System.currentTimeMillis();
16            for(int i = 0; i < N; i++) {
17                buffer.append(i);
18                buffer.length();
19            }
20            costTime = System.currentTimeMillis() - beginTime;
21            bufferTotalTime  += costTime;
22            System.out.println("StringBuffer  费时: --->> " + costTime);
23            beginTime = System.currentTimeMillis();
24            for(int i = 0; i < N; i++) {
25                builder.append(i);
26                builder.length();
27            }
28            costTime = System.currentTimeMillis() - beginTime;
29            buliderTotalTime += costTime;
30            System.out.println("StringBuilder 费时: --->> " + costTime);
31            System.out.println("----------------------------------<" + (COUNT + 1) + ">");
32        }
33        System.out.println("bufferTotalTime / buliderTotalTime = " + (bufferTotalTime / buliderTotalTime));
34

后台输出结果:

 1
 2----------------------------------<10>
 3StringBuffer  费时: --->> 32.0
 4StringBuilder 费时: --->> 16.0
 5----------------------------------<10>
 6----------------------------------<9>
 7StringBuffer  费时: --->> 21.0
 8StringBuilder 费时: --->> 15.0
 9----------------------------------<9>
10----------------------------------<8>
11StringBuffer  费时: --->> 25.0
12StringBuilder 费时: --->> 35.0
13----------------------------------<8>
14----------------------------------<7>
15StringBuffer  费时: --->> 24.0
16StringBuilder 费时: --->> 8.0
17----------------------------------<7>
18----------------------------------<6>
19StringBuffer  费时: --->> 48.0
20StringBuilder 费时: --->> 38.0
21----------------------------------<6>
22----------------------------------<5>
23StringBuffer  费时: --->> 22.0
24StringBuilder 费时: --->> 8.0
25----------------------------------<5>
26----------------------------------<4>
27StringBuffer  费时: --->> 23.0
28StringBuilder 费时: --->> 9.0
29----------------------------------<4>
30----------------------------------<3>
31StringBuffer  费时: --->> 25.0
32StringBuilder 费时: --->> 7.0
33----------------------------------<3>
34----------------------------------<2>
35StringBuffer  费时: --->> 23.0
36StringBuilder 费时: --->> 7.0
37----------------------------------<2>
38----------------------------------<1>
39StringBuffer  费时: --->> 78.0
40StringBuilder 费时: --->> 59.0
41----------------------------------<1>
42----------------------------------<0>
43StringBuffer  费时: --->> 21.0
44StringBuilder 费时: --->> 11.0
45----------------------------------<0>
46bufferTotalTime / buliderTotalTime = 1.6056338028169015
47

StringBuffer 在测试中平均耗时是 StringBuilder 的 1.6 倍以上,再测多次,都是 1.6 倍以上。StringBuffer 和 StringBuilder 的性能孰更加优,一眼明了。

最后,如果你想知道 @3 (在上面我已经用红色粗体标出) 的结果,不妨说一下:
eg:
String mail = "fancydeepin" + "@" + "yeah.net";

来,一起来看一下上面的这条语句,想一下,这条语句将会创建几个 String 的对象呢?
1个? 2个? 3个? 4个? 5个? ... ...

也许你会认为是4个,它们分别是:"fancydeepin"、"@"、"yeah.net"、"fancydeepin@yeah.net"
也许你会认为是5个,它们分别是:"fancydeepin"、"@"、"yeah.net"、"fancydeepin@"、"fancydeepin@yeah.net"
也许 ... ...

但实际上,这条语句只创建了一个 String 对象!
为什么会这样呢?原因很简单,这是因为,mail 在 编译的时候其值就已经确定,它就是 "fancydeepin@yeah.net" 。
当程序处于运行期间且当上面的这条语句被执行到的时候,那么 mail 所引用的对象就会被创建,而 mail 的值由于在编译的时候已经确定
它是  "fancydeepin@yeah.net" ,所以最终只有一个 String 对象被创建出来,而这个对象就是  "fancydeepin@yeah.net" 对象。www.2cto.com

这样解释都能够理解了吧?真的理解了吗?是真的理解才好,不妨再来看一个:
eg:
String mail = new String("fancydeepin@yeah.net");

这回又创建了几个对象呢?
答案是2个。为什么不是1个了呢?2个又是哪2个呢?
可以很肯定的告诉你,它们分别是: "fancydeepin@yeah.net"、new String()
这是因为,这回 mail 在编译的时候它的值是还不能够确定的,编译只是将源代码翻译成字节码,程序还并没有跑起来,还 new 不了对象,
所以在编译完成之后,mail 的值是还不能够确定的。
当程序处于运行期间且当上面的这条语句被执行到的时候,这时候才开始去确定 mail 的引用对象,首先,"fancydeepin@yeah.net" 对象会被创建,
之后,再执行 new String(),所以这条语句最后实际上是创建了 2个 String 对象。

 

 

 作者:fancydeepin

转自:http://www.2cto.com/kf/201207/139560.html

分享到:
评论

相关推荐

    Java中字符串去重的特性介绍

    Java中的字符串去重特性是Java 8 Update 20引入的一种优化机制,旨在减少内存消耗,特别是对于大量字符串操作的应用。这一特性依赖于G1(Garbage First)垃圾回收器,G1是Java 8中默认关闭的一个高级垃圾回收算法。...

    Java中的字符串驻留

    Java中的字符串驻留机制是为了优化字符串的使用,减少内存中不必要的重复对象。它涉及到Java的字符串常量池,这是一个特殊区域,存储了程序中所有的字符串字面量(literal strings)和通过`intern()`方法添加的字符...

    C#字符串内存分配与驻留池学习分享

    总的来说,理解和正确使用C#的字符串驻留池可以显著提高程序的性能,特别是在处理大量重复字符串时。通过字面量和`Intern`方法,开发者可以有效地控制字符串的内存分配,优化程序资源的使用。在编写高性能的C#代码时...

    C#语法字符串与数组的研究

    C#使用字符串驻留机制来优化内存使用,避免相同字符串的多次拷贝。这种机制使得相同的文本常量在内存中只会有一份拷贝。 字符串的基本操作包括: 1. **索引器**:可以通过索引访问字符串中的单个字符,如`string...

    十大常见Java String问题_动力节点Java学院整理

    如果涉及到字符串驻留(String Interning),则"=="也可能返回内容相等的字符串是否为同一个对象的结果。 2. **敏感信息处理:为何使用char[]优于String?** String对象是不可变的,意味着一旦创建就不能修改。这...

    .NET再谈String

    【字符串驻留的深入】当创建一个新的字符串时,CLR会检查字符串驻留池,如果池中已经存在相同内容的字符串,那么新字符串就会共享同一块内存空间。如果不存在,就会在托管堆上分配新的内存,并将新字符串添加到驻留...

    浅谈C#中的string驻留池

    首先,我们来了解一下什么是字符串驻留池。简单来说,驻留池是一种内存分配策略,允许相同内容的字符串对象在内存中只存在一份。这种策略特别适用于那些大量使用字符串字面量的情况。例如,在程序中多次出现"hello...

    Java8新特性之字符串去重介绍

    字符串驻留是在字符串常量池中实现的,当创建新的字符串常量时,如果常量池中已有相同内容的字符串,会直接返回该字符串的引用,从而避免创建新的对象。而字符串去重则是在运行时动态进行的,针对的是堆中的字符串...

    字符串内存驻留机制详解示例

    字符串内存驻留机制是指CLR在内存中维护一个字符串驻留池,池中存储着所有已经创建的字符串对象实例。这样,当我们创建一个新的字符串对象时,CLR会首先检查驻留池中是否已经存在该字符串,如果存在,就返回该字符串...

    java6string源码-opengrok:ssh的克隆://anon@hg.opensolaris.org/hg/opengrok/tru

    通过研究 Java 6 的 `String` 源码,我们可以了解到字符串对象的存储方式、常量池的工作原理以及字符串操作的方法实现。这些知识对于优化代码性能、理解和解决字符串相关问题以及深入学习 Java 内存管理都是至关重要...

    Python数据分析及可视化-51

    然而,这个机制不适用于长字符串,如`a = "1234"*5000000`和`b = "1234"*5000000`,尽管它们内容相同,但会在内存中分配不同的地址,这是因为长字符串不支持内存驻留以节省内存空间。 此外,Python允许使用中文作为...

    Java字符串的10大热点问题盘点

    下面我为大家总结了10条Java开发者经常会提的关于Java字符串的问题,如果你也是Java初学者,仔细看看吧:  1、如何比较字符串,应该用”==”还是equals()?  总的来说,”==”是用来比较字符串的引用地址,而...

    JAVA面试葵花宝典.doc

    【JAVA面试葵花宝典】 ...除此之外,Java面试还可能涉及异常处理、集合框架、多线程、IO流、网络编程、设计模式、JVM内存模型、数据库连接池以及各种框架的使用等知识点。掌握这些核心概念,能帮助你在面试中脱颖而出。

    C#中字符串的一般性和特殊性

    2. **字符串驻留池(String Intern Pool)** 这是C#字符串的另一个独特特性。字符串驻留池是一种优化机制,用于存储和重用具有相同值的字符串对象。当创建一个新的字符串实例时,如果该字符串的值与已存在于驻留池...

    Python数据分析及可视化-71

    在Python中,对于短字符串(通常长度小于20个字符),存在内存驻留机制,这意味着当创建的字符串内容相同时,它们会指向内存中的同一个位置,即id(a) == id(b)会返回True。这是为了节省内存资源。然而,对于长字符串...

    JAVA性能--高效率执行JAVA[参考].pdf

    10. **尽量使用基本数据类型代替对象字符串**:直接引用字符串常量池中的字符串比创建新的String对象更高效。 11. **单线程使用HashMap和ArrayList**:在单线程环境中,HashMap和ArrayList比同步的Hashtable和...

    java面试题

    - **提高性能**:由于 `String` 对象的不可变性,Java 虚拟机能够缓存字符串常量池中的 `String` 对象,从而避免重复创建相同的字符串对象,提高了内存利用效率。 - **安全性增强**:在 Java 中,字符串经常用于表示...

Global site tag (gtag.js) - Google Analytics