美高梅网投网址:图解Java中String不可变性,不可

2019-11-03 20:23 来源:未知

一、图解Java中String不可变性,javastring

这里有一堆例子来说明Java的String的不可变性。

1、声明一个String

String s = "abcd";

美高梅网投网址 1
s 变量保存string对象的引用,下面的箭头解释成保存了哪个对象的引用。

 

2、 给一个String 变量赋值为另外一个String 变量。

String s2 = s;

String对象不可变展示2变量s2 保存这相同引用的值,它们都指向了同一对象的值。

 

3、连接String

 

s = s.concat("ef");

变量s 现在保存的是新创建的sting对象的引用。

 

美高梅网投网址 2

总结:
一旦一个string 被在内存(堆)中创建,它就是不可以被改变的。我们应该注意的是所有的String方法都不会改变一个string的本身,而是返回一个新的string。

如果我们需要一个可以被改变的string,那么我们可以使用StringBuffer(译者注:线程安全)或StringBuilder。否则每创建一个新的string的时候,会浪费大量的时间在垃圾收集上。

这里有个StringBuilder的应用例子。

public static String readFileToString() throws IOException {
        File dirs = new File(".");
        String filePath = dirs.getCanonicalPath()   File.separator "src" File.separator "TestRead.java";

        StringBuilder fileData = new StringBuilder(1000);//Constructs a string buffer with no characters in it and the specified initial capacity
        BufferedReader reader = new BufferedReader(new FileReader(filePath));

        char[] buf = new char[1024];
        int numRead = 0;
        while ((numRead = reader.read(buf)) != -1) {
            String readData = String.valueOf(buf, 0, numRead);
            fileData.append(readData);
            buf = new char[1024];
        }

        reader.close();

        String returnStr = fileData.toString();
        System.out.println(returnStr);
        return returnStr;
    }

这里有一堆例子来说明Java的String的不可变性。 1、声明一个String String s = "abcd"; s 变量保存string对象的...

从String类型的发展历程到源码浅析,以及一些常用方法、问题介绍,最后通过在线文档使用帮助更进一步了解细节。

1. java不可变性初探

我们先看下面一个例子:代码如下:

 1     import java.math.BigInteger;  
 2     public class BigProblem {  
 3         public static void main(String[ ] args) {  
 4             BigInteger fiveThousand  = new BigInteger("5000");  
 5             BigInteger fiftyThousand = new BigInteger("50000");  
 6             BigInteger fiveHundredThousand = new BigInteger("500000");  
 7             BigInteger total = BigInteger.ZERO;  
 8             total.add(fiveThousand);  
 9             total.add(fiftyThousand);  
10             total.add(fiveHundredThousand);  
11             System.out.println(total);  
12         }  
13     }

你可能会认为这个程序会打印出555000。毕竟,它将total设置为用BigInteger表示的0,然后将5,000、50,000和500,000加到了这个变量上。如果你运行该程序,你就会发现它打印的不是555000,而是0。很明显,所有这些加法对total没有产生任何影响。

对此有一个很好理由可以解释:BigInteger实例是不可变的。String、BigDecimal以及包装器类型:Integer、Long、Short、Byte、Character、Boolean、Float和Double也是如此,你不能修改它们的值。我们不能修改现有实例的值,对这些类型的操作将返回新的实例。起先,不可变类型看起来可能很不自然,但是它们具有很多胜过与其向对应的可变类型的优势。不可变类型更容易设计、实现和使用;它们出错的可能性更小,并且更加安全[EJ Item 13]。

为了在一个包含对不可变对象引用的变量上执行计算,我们需要将计算的结果赋值给该变量。这样做就会产生下面的程序,它将打印出我们所期望的555000, 代码如下:

 

美高梅网投网址 3美高梅网投网址 4

 1     import java.math.BigInteger;  
 2     public class BigProblem {  
 3         public static void main(String[] args) {  
 4             BigInteger fiveThousand  = new BigInteger("5000");  
 5             BigInteger fiftyThousand = new BigInteger("50000");  
 6             BigInteger fiveHundredThousand = new BigInteger("500000");  
 7             BigInteger total = BigInteger.ZERO;  
 8             total = total.add(fiveThousand);  
 9             total = total.add(fiftyThousand);  
10             total = total.add(fiveHundredThousand);  
11             System.out.println(total);  
12         }  
13     }

View Code

概述

字符串类型是编程语言中最常见的一种基本类型了,当然可能有一些语言本身并没有实现这种类型,比如C语言。但是如果需要的话,我们完全能够自己创造一个这样的类型。 为什么要重识String呢?因为我发现很多时候越是基础的东西反而越重要,越底层的东西往往越复杂。如果没有把这些基础的知识搞懂的话,在平时的开发中可能就会出现一些不容易被发现的问题。因此,我们需要溯本追源,重新再认识这些基本知识。

2.String不可变性实现分析

根据JDK中java.lang.String的源码进行分析,从中可以得出String类型的对象不可变的原因,大致上有如下两个:
1、java.lang.String类型在实现时,其内部成员变量全部使用final来修饰,保证成员变量的引用值只能通过构造函数来修改;
2、java.lang.String类型在实现时,在外部可能修改其内部存储值的函数实现中,返回时一律构造新的String对象或者新的byte数组或者char数组;
第2的重要性在于,假如通过String类型的toCharArray方法可以直接访问String类型内部定义的char数组,那么即便String类型内部的char数组使用了final来修饰,也仅仅保证这个成员变量的引用不可变,而无法保证引用指向的内存区域不可变。由上述两点,保证外部不可能修改java.lang.String类型对象的内部属性,从而保证String对象是不可变的。
提到String,就不得不提一下JDK中存在另外两个常用来表示字符串的类,StringBuffer和StringBuilder。根据注释,StringBuffer可谓老资格了,从JDK1.0时即伴随Java征战世界,而StringBuilder直到JDK1.5时才出现。
面试时,StringBuffer和StringBuilder的区别也是常问的话题,有些没有开发经验,对多线程编码不了解、对synchronized的使用不熟悉的兄弟,很容易在这个问题上吃亏。
StringBuffer和StringBuilder的共同点:
1、都是可变对象,对象内的字符缓存会随着拼接操作而动态扩展;
2、用来完成字符串拼接操作;
3、构造时传入内部缓存大小时,可以降低缓存扩展的次数,明显提升字符串拼接操作的效率;
StringBuffer和StringBuilder的区别:
1、StringBuilder的方法都是线程不安全的,从另外一个角度讲,StringBuilder类型的对象在做字符串拼接操作时,由于少了线程同步的操作,执行效率上有很大提升;
2、StringBuffer的方法都加上了synchronized关键字,因而在一定的场景下,StringBuffer类型的对象都是线程安全的,但在执行效率上,由于多了线程同步的操作,因而会有少许的损失;
在大多数场景下,字符串拼接操作都是不需要考虑多线程环境下对结果的影响的,因而使用StringBuilder类型可以提升代码的执行效率。
在多个线程的代码中共享同一个StringBuffer类型的对象时,需要关注synchronized关键字对最终结果的影响。由于StringBuffer类的实现中,仅仅对每个方法使用了synchronized修饰,这只能保证在多线程场景下,访问StringBuffer对象的同一个方法时可以保证最终结果的一致性,假如一个线程访问A方法,另外一个线程方法B方法,则由于加锁对象的不同,可能会出现不一致的现象,这是需要程序员特别要注意的地方。类似的,可以参考Vector的实现和应用场景。

从char到String

最早接触编程语言,是从C语言开始。C语言有char类型,但是并没有string类型。这是因为C语言是静态弱类型语言,意味着类型(包括 size 等信息,你使用 sizeof 就是编译时候得到的)在编译的时候就能确定下来。string类型的大小不能在编译的时候确定下来,因为你将存储 string 的长度不是固定的,可大可小。而且C语言可以通过指针更加灵活的分配内存,也可以通过struct自己构建一个string类,因此它也就没有在标准库里面去实现string类。但是这其实还是有点不太方便,因此后面的语言包括C ,Java都在标准库里面实现了string类。如果查看源码的话,我们可以知道其实Java中的String类也是通过char类型来实现。字符串本身就是一个一个字符连接起来的,再通过一定的算法来分配大小空间。

3.String不可变性的好处

最流行的Java面试题之一就是:什么是不可变对象(immutable object),不可变对象有什么好处,在什么情况下应该用,或者更具体一些,Java的String类为什么要设成immutable类型?
不可变对象,顾名思义就是创建后不可以改变的对象,典型的例子就是Java中的String类。

 代码如下:

String s = "ABC";  
s.toLowerCase();

如上s.toLowerCase()并没有改变“ABC“的值,而是创建了一个新的String类“abc”,然后将新的实例的指向变量s。

相对于可变对象,不可变对象有很多优势:
1).不可变对象可以提高String Pool的效率和安全性。如果你知道一个对象是不可变的,那么需要拷贝这个对象的内容时,就不用复制它的本身而只是复制它的地址,复制地址(通常一个指针的大小)需要很小的内存效率也很高。对于同时引用这个“ABC”的其他变量也不会造成影响。
2).不可变对象对于多线程是安全的,因为在多线程同时进行的情况下,一个可变对象的值很可能被其他进程改变,这样会造成不可预期的结果,而使用不可变对象就可以避免这种情况。
当然也有其他方面原因,但是Java把String设成immutable最大的原因应该是效率和安全。

 

答案二:

这是一个老生常谈的话题(This is an old yet still popular question). 在Java中将String设计成不可变的是综合考虑到各种因素的结果,想要理解这个问题,需要综合内存,同步,数据结构以及安全等方面的考虑. 在下文中,我将为各种原因做一个小结。

1. 字符串常量池的需要

字符串常量池(String pool, String intern pool, String保留池) 是Java堆内存中一个特殊的存储区域, 当创建一个String对象时,假如此字符串值已经存在于常量池中,则不会创建一个新的对象,而是引用已经存在的对象。
如下面的代码所示,将会在堆内存中只创建一个实际String对象. 代码如下:

String s1 = "abcd";  
String s2 = "abcd";  

 

示意图如下所示:

 

 

假若字符串对象允许改变,那么将会导致各种逻辑错误,比如改变一个对象会影响到另一个独立对象. 严格来说,这种常量池的思想,是一种优化手段.

请思考: 假若代码如下所示,s1和s2还会指向同一个实际的String对象吗? 代码如下:

String s1= "ab"   "cd";  
String s2= "abc"   "d";  

 

也许这个问题违反新手的直觉, 但是考虑到现代编译器会进行常规的优化, 所以他们都会指向常量池中的同一个对象. 或者,你可以用 jd-gui 之类的工具查看一下编译后的class文件.

**2. 允许String对象缓存HashCode

**Java中String对象的哈希码被频繁地使用, 比如在hashMap 等容器中。

 

字符串不变性保证了hash码的唯一性,因此可以放心地进行缓存.这也是一种性能优化手段,意味着不必每次都去计算新的哈希码. 在String类的定义中有如下代码:代码如下:

private int hash;//用来缓存HashCode  

**3. 安全性

**String被许多的Java类(库)用来当做参数,例如 网络连接地址URL,文件路径path,还有反射机制所需要的String参数等, 假若String不是固定不变的,将会引起各种安全隐患。
假如有如下的代码:

boolean connect(string s){
    if (!isSecure(s)) { 
throw new SecurityException(); 
}
    // 如果在其他地方可以修改String,那么此处就会引起各种预料不到的问题/错误 
    causeProblem(s);
}

总体来说, String不可变的原因包括 设计考虑,效率优化问题,以及安全性这三大方面. 事实上,这也是Java面试中的许多 "为什么" 的答案。

答案三:String类不可变性的好处

String是所有语言中最常用的一个类。我们知道在Java中,String是不可变的、final的。Java在运行时也保存了一个字符串池(String pool),这使得String成为了一个特别的类。

String类不可变性的好处

1.只有当字符串是不可变的,字符串池才有可能实现。字符串池的实现可以在运行时节约很多heap空间,因为不同的字符串变量都指向池中的同一个字符串。但如果字符串是可变的,那么String interning将不能实现(译者注:String interning是指对不同的字符串仅仅只保存一个,即不会保存多个相同的字符串。),因为这样的话,如果变量改变了它的值,那么其它指向这个值的变量的值也会一起改变。
2.如果字符串是可变的,那么会引起很严重的安全问题。譬如,数据库的用户名、密码都是以字符串的形式传入来获得数据库的连接,或者在socket编程中,主机名和端口都是以字符串的形式传入。因为字符串是不可变的,所以它的值是不可改变的,否则黑客们可以钻到空子,改变字符串指向的对象的值,造成安全漏洞。
3.因为字符串是不可变的,所以是多线程安全的,同一个字符串实例可以被多个线程共享。这样便不用因为线程安全问题而使用同步。字符串自己便是线程安全的。
4.类加载器要用到字符串,不可变性提供了安全性,以便正确的类被加载。譬如你想加载java.sql.Connection类,而这个值被改成了myhacked.Connection,那么会对你的数据库造成不可知的破坏。
5.因为字符串是不可变的,所以在它创建的时候hashcode就被缓存了,不需要重新计算。这就使得字符串很适合作为Map中的键,字符串的处理速度要快过其它的键对象。这就是HashMap中的键往往都使用字符串。
以上就是我总结的字符串不可变性的好处。

String的不可变性(Immutability)

4. 例子

美高梅网投网址 5美高梅网投网址 6

  1 package cn.xy.test;
  2 public class StringTest
  3 {
  4  /**
  5   * a的值在编译时就被确定下来,故其值"xy"被放入String的驻留池(驻留池在堆中)并被a指向。
  6   * b的值在编译时也被确定,那么b的值在String的驻留池中找是否有等于"xy"的值,有的话也被b指向。
  7   * 故两个对象地址一致
  8   * @return true
  9   */
 10  public static Boolean testString1()
 11  {
 12   String a = "xy";
 13   String b = "xy";
 14   return a == b;
 15  }
 16  
 17  /**
 18   * b的值在是两个常量相加,编译时也被确定。
 19   * @return true
 20   */
 21  public static Boolean testString2()
 22  {
 23   String a = "xyy";
 24   String b = "xy"   "y";
 25   return a == b;
 26  }
 27  /**
 28   * b的值为一个变量和一个常量相加,无法编译时被确定,而是会在堆里新生成一个值为"abc"的对象
 29   * @return false
 30   */
 31  public static Boolean testString3()
 32  {
 33   String a = "xyy";
 34   String b = "xy";
 35   b = b   "y";
 36   return a == b;
 37  }
 38  
 39  /**
 40   * b的值都无法编译时被确定,而是会在堆里分别新生成一个对象叫"xyy"。
 41   * @return false
 42   */
 43  public static Boolean testString4()
 44  {
 45   String a = "xyy";
 46   String b = "xy".concat("y");
 47   return a == b;
 48  }
 49  
 50  /**
 51   * new String()创建的字符串不是常量,不能在编译期就确定,所以new String() 创建的字符串不放入常量池中,它们有自己的地址空间。 
 52   * a,b的值都无法编译时被确定,会在堆里分别新生成一个值为"xy"的对象。
 53   * @return fasle
 54   */
 55  public static Boolean testString5()
 56  {
 57   String a = new String("xy");
 58   String b = new String("xy");
 59   return a == b;
 60  }
 61  /**
 62   * intern()把驻留池中"xy"的引用赋给b。
 63   * @return true
 64   */
 65  public static Boolean testString6()
 66  {
 67   String a = "xy";
 68   String b = new String("xy");
 69   b = b.intern();
 70   return a == b.intern();
 71  }
 72  
 73  /**
 74   * char的toString方法返回的是一个char对象的字符串,而不是我们想象的"xy"
 75   * @return false
 76   */
 77  public static Boolean testString7()
 78  {
 79   String b = "xy";
 80   char[] a = new char[]{'x','y'};
 81   return a.toString().equals(b);
 82  }
 83  
 84 
 85  /**
 86   * char是一种新的类型,不存在驻留池的概念。
 87   * @return fasle
 88   */
 89  public static Boolean testString8()
 90  {
 91   String b = "xy";
 92   char[] a = new char[]{'x','y'};
 93   return a.toString() == b;
 94  }
 95  
 96 /**
 97   * String不可变性的体现
 98   */
 99  String str = "xy";
100  public String chage(String str)
101  {
102   str = "xyy";
103   return str;
104  }
105  
106  /**
107   * 一般引用类型的可变性(传值的时候把地址传过去,相当于把仓库的要是交给方法,方法拿到钥匙去移动仓库里的东西)
108   */
109  Person p = new Person("xy");
110  public String changePerson(Person p)
111  {
112   p.setName("xyy");
113   return p.toString();
114  }
115  public static void main(String[] args)
116  {
117   print(testString1()); // true
118   print(testString2()); // true
119   print(testString3()); // fasle
120   print(testString4()); // false
121   print(testString5()); // false
122   print(testString6()); // true
123   print(testString7()); // false
124   print(testString8()); // false
125   StringTest t = new StringTest();
126   print(t.str); // xy
127   print(t.chage(t.str)); // xxy
128   print(t.str); // xy
129   print(t.p.toString()); //xy
130   print(t.changePerson(t.p)); //xyy
131   print(t.p.toString()); //xyy
132  }
133  
134  public static void print(Object o)
135  {
136   System.out.println(o);
137  }
138 }

View Code

参考:

  

什么是不可变性

字符串类型的最基本的一个特点就是不可变性。通过final关键字来修饰。那究竟什么是不可变性呢?我们初始化一个字符串:

String s = "abcd";

美高梅网投网址 7
如图,若堆中原本没有字符串"abcd"对象,则会重新分配一块空间用于保存字符串"abcd"。变量s只是保存一个string对象的引用即字符串"abcd"在堆中的内存地址,变量s本身是存储在栈中的。

若将变量s赋值给另外一个变量s2:

String s2 = s;

则变量s2指向同一个字符串"abcd"对象的引用,即和变量s一样保存"abcd"的内存地址。
美高梅网投网址 8

当我们改变字符串的内容呢?比如追加"ef"到"abcd"上变成"abcdef"。

s = s.concat("ef");

美高梅网投网址 9

如图,那么实际是重新new了一个字符串对象"abcdef",在堆中又分配了一块地址用于存储。而变量s的也指向了新的地址。

所以,一旦在堆中创建了一个字符串,那么它就是不可变的。所有的String方法,比如substring(),replace(),toUpper等等其实是创建了一个新的对象。如果我们需要一个可变的字符串对象,那么可以使用StringBuffer或者StringBuilder

为什么String要不可变

那么问题来了,为什么String类型要被设计成不可变的呢?主要有以下几个因素。

  1. 提高性能:
    当一个String对象被创建的时候,如果堆中不存在实例,则会创建一个实例。如果已经存在,则实例的引用就会被返回,这样在很多大量重复的字符串处理的时候,就不需要创建很多新的对象,浪费内存空间。

  2. 缓存哈希码: 字符串的哈希码经常在很多情况下被使用,比如HashMap和HashSet。作为不可变性能保证哈希码的一致性,每次使用哈希码的时候不需要再重新计算。在String类中,有一个字段用来保存哈希码。

     private int hash;//this is used to cache hash code.  
    
  3. 方便其他类使用: 如果String类型是可变的,那么很多其他类再使用它的时候,可能会出现矛盾的情况。

     HashSet<String> set = new HashSet<String>(); set.add(new String("a")); set.add(new String("b")); set.add(new String("c")); for(String a: set)     a.value = "a";
    

    虽然String类里面没有一个value的属性,这里只是举个例子。如果String类型是可变的,那么就违反了HashSet的设计原则:HashSet里面的每个元素必须是不同的。

  4. 安全性:
    String在很多Java类中作为参数使用,包括网络连接,文件操作等。假设String是可变的,连接或者文件就可能被篡改,就将导致很严重的安全隐患。

  5. 线程安全:
    由于String是不可变的,那么自然的它就可以在多线程中共享。而不用去考虑同步的一些处理。

总之,由于这些因素String被设计成是不可变的。这些因素也是一个类通常应当优选考虑设计成不可变的的原因。

设置不可变类的一些原则:

  • 将类声明为final,所以它不能被继承。
  • 将所有的成员声明为私有的,这样就不允许直接访问这些成员。
  • 对变量不要提供setter方法。
  • 将所有可变的成员声明为final,这样只能对它们赋值一次。
  • 通过构造器初始化所有成员,进行深拷贝(deep copy)。
  • 在getter方法中,不要直接返回对象本身,而是克隆对象,并返回对象的拷贝。

源码浅析

美高梅网投网址 10
String对象分别实现了序列化接口Serializable,比较接口Comparable以及字符序列接口CharSequence。底层使用一个不可变的char数组存储字符串中的各个字符。通过不同参数的构造函数来初始化,包括可通过byte数组,char数组,String对象来初始化,并可设置字符编码。String类型的编码方式是与JVM编码方式和本机操作系统默认字符集有关的。可通过System.getProperty("file.encoding")查看本地默认编码。

常用方法

通过Java在线接口文档查看常用方法说明。

charAt

返回char指定索引处的值。

compareTo

美高梅网投网址 11
按照字典顺序比较两个字符串,比较基于字符串中每个字符的Unicode值。如果字符串相等,结果为零。两个字符串长度相等,逐一比较每个字符的值,直到某个值不相等,返回第一个字符串与第二个字符串第一个不相等字符的值差异。若大于0,则表示第一个字符串在字典中顺序大于第二个字符串。反之亦然。如果对两个超长的字符串进行比较还是非常费时间的。

indexOf

返回指定子字符串第一次出现在字符串中的索引。

concat

将指定的字符串连接到该字符串的末尾。
美高梅网投网址 12
首先使用Arrays.copyOf方法创建一个新的字符数组,并将长度扩大为
原字符串长度加上要连接的字符串长度。然后通过getChars方法,内部实际是通过调用System.arraycopy方法来实现数组的复制,返回一个新的字符数组,最后通过String的内部构造方法,返回一个新的字符串。

contains(CharSequence)

当且仅当此字符串包含指定的char值序列时才返回true。
内部通过indexOf方法实现。

matches

若字符串满足指定的正则表达式,返回true。
通过调用Pattern.matches(regex, String)方法实现。

replaceAll(String regex, String replacement)

用给定的替换替换与给定的正则表达式匹配的此字符串的每个子字符串。
Pattern.compile.matcher返回正则匹配器,在通过Matcher.replaceAll替换所有匹配项。

split

将此字符串分割为给定的正则表达式的匹配。
这块代码内部实现比较麻烦,这里简单说明一下用法。

  1. 若需要分割的字符是正则表达式的元字符".$|()[{^?* ",则需要加上转义符合进行分割。比如以'|'分割的,要使用"|"进行分割。

     String a = "hhh|sdf|eee"; String arr[] = a.split("\|"); for (String s : arr){     System.out.println; }
    
  2. 多个分隔符,使用'|'进行连接,比如

     String a = "aaa=? and bbb=? or ccc=? and ddd=?"; String arr[] = a.split("and|or"); for (String s : arr){     System.out.println; }
    

    使用"and|or"同时分割and和or的字符串。

  3. 直接使用正则表达式进行分割。

     String a = "ab cd^efgh---234---[[.....["; //以一个或多个任意不是字母,数字,下划线,汉字的字符作为分隔符,即上面的 、^、---、.....、[、[[符号均能作为分隔符 String arr[] = a.split("\W "); //输出[ab, cd, efgh, 234] System.out.println(Arrays.toString;
    

substring(int beginIndex, int endIndex)

返回一个字符串,该字符串是此字符串的子字符串。substring在jdk7实现有变化。在jdk7之前,substring返回的对象是原字符串。
美高梅网投网址 13

//JDK 6String(int offset, int count, char value[]) {    this.value = value;    this.offset = offset;    this.count = count;}public String substring(int beginIndex, int endIndex){    //check boundary    return  new String(offset   beginIndex, endIndex - beginIndex, value);}

当substring被调用后,它创建了一个新的String对象,当时新的String的value仍然指向同一个堆中的char数组。新的String对象和原来的String对象只是count和offset的不同。也就是表面上是创建了一个新的String对象,实际还是指向原来那个String对象。
美高梅网投网址 14
而在jdk7以后,substring方法被调用后是真正地在堆中创建了一个新的char数组。

//JDK 7public String(char value[], int offset, int count) {    //check boundary    this.value = Arrays.copyOfRange(value, offset, offset   count);}public String substring(int beginIndex, int endIndex){//check boundary    int subLen = endIndex - beginIndex;    return new String(value, beginIndex, subLen);}

trim()

返回一个字符串,其值为此字符串,并删除任何前导和尾随空格。

valueOf

返回int类型参数的字符串形式。内部通过Integer.toString()方法实现。这里另外补充一下,Integer.parseInt和Integer.valueOf以及类似的parseDouble(),parseLong()方法和valueOf()方法的区别。不同点在于parseInt返回int基本类型。而valueOf返回Integer对象。还有valueOf内部其实还是使用parseInt方法来实现的。

hash()

美高梅网投网址 15
只说明一下String的哈希值递归算法:

h = s[0]   (s[1] * 31   s[0])   ((s[1] * 31   s[0]) * 31   s[2])   ...   (h[n-2] * 31)   s[n-1]= s[0] * 31 ^    s[0] * 31 ^    ...   s[0] * 31 ^ 0   s[1] * 31 ^    s[1] * 31 ^    ...   s[1] * 31 ^ 0   ...   s[n-1] * 31 ^ 0= s[0] * 31 ^    s[1] * 31 ^    ...   s[n-1]

equals()

美高梅网投网址 16

  1. 首先通过==判断要比较的对象是否在内存中相同地址,即是否同一个对象。若是则直接返回true。
  2. 接着判断要比较的对象首先是字符串对象,然后再从第一位字符开始比较,若中间有某一位字符不同直接返回false。
  3. 最后比较所有字符都相同的话,返回true。

常见问题

使用""还是构造器创建String对象

Java中创建String对象有两种方式:

String x = "abc";String y = new String("abc");

这两种方式的主要区别就是,使用双引号""创建的对象,如果已经在堆中存在的话,那么就返回这个对象,否则就创建一个新的对象。而使用new创建的对象就会直接创建一个新的对象。

String a = "abcd";String b = "abcd";String c = new String("abcd");System.out.println;  // TrueSystem.out.println(a.equals; // TrueSystem.out.println;  // FalseSystem.out.println(a.equals; // True

String,StringBuffer,StringBuilder区别

因为String对象是不可变的,当我们需要大量频繁地修改字符串时,为了避免产生太多的String对象,可以使用可变类型的StringBuilder或StringBuffer。

三者在执行速度方面的比较:StringBuilder > StringBuffer > String。

StringBuilder:线程非安全的。JDK1.5引入的。

StringBuffer:线程安全的。有加锁开销,效率略低。

  1. 如果要操作少量的数据用String
  2. 单线程操作字符串缓冲区下操作大量数据用StringBuilder
  3. 多线程操作字符串缓冲区下操作大量数据用StringBuffer

现在jdk1.5以后的String使用 拼接字符串都是在内部使StringBuilder进行替换StringBuffer的线程安全的场景基本没有。
所以,字符串使用 拼接和使用StringBuilder本质上是一样的。

参考资料

  1. Simple Java
  2. String详解
  3. Java String类源码分析
TAG标签:
版权声明:本文由美高梅网投平台发布于计算机网络,转载请注明出处:美高梅网投网址:图解Java中String不可变性,不可