java string hash变量_Java String引起的常量池、String类型传参、“==”、“equals”、“hashCode”问题 细节分析...

在学习javase的过程中，总是会遇到关于String的各种细节问题，而这些问题往往会出现在Java攻城狮面试中，今天想写一篇随笔，简单记录下我的一些想法。话不多说，直接进入正题。

1.String常量池、“==”、“equals”：

先看一段代码：

1 String s1 = "123";2 String s2 = "123";3 System.out.println("s1==s2? "+(s1==s2));//true4

5 //使用new关键字创建一个String对象s3,看看会不会出现不一样的情况？

6 String s3 = new String("123");7 System.out.println("s1==s3? "+(s1==s3));//false8

9 //如果不使用==比较，而是equals比较呢？

10 System.out.println("s1.equals(s3)? "+s1.equals(s3));//true

运行结果:

1 s1==s2? true

2 s1==s3? false

3 s1.equals(s3)? true

看到这里，有的人会迷惑了：为什么s1==s2？为什么s1==s3是false？而s1.equals(s3)却是true？

在Java语言中，==和equals都有比较的作用。这两种方式有什么区别呢？为什么要设计出来这两种方式呢？

我们知道java中有8种基本类型和非基本类型(对象类型或者引用类型)

基本类型有：byte，short，int，long，float，double，boolean，char；

对象类型：除了以上8种基本类型

对于基本类型，使用==就可以直接进行比较是否相等，而对于对象类型，使用==只会比较该对象变量的内存地址，在Java中每个新建的对象都有自己的一块内存，只要使用了new就是两个不同的对象，所以此时==显然不能满足我们的需求，自然s1==s3会是false。可是我们确实想比较两个对象变量指向的值，怎么办呢？于是，equals()被设计出来了。equals()是Object类中的一个方法，通过查阅Object中equals()方法的API

1 public booleanequals(Object obj) {2 return (this ==obj);3 }

我们发现：在Object类中equals()方法竟然也是使用了==符号来进行对象的比较！！！ 那岂不是完犊子？跟我们想要的功能不一样啊。可是，我们也应该知道一句话：Java中万物皆对象，Object是所有对象的父类！对象被创建后都默认继承了Object类(根类)，拥有了Object类的方法和字段，这就是Java面向对象的一个特性：继承。于是被创建的对象就可以在自己对应的类中，对Object类中的方法进行重写，例如本例中String类中对equals()方法重写的代码是：

1 public booleanequals(Object anObject) {2 if (this ==anObject) {3 return true;4 }5 if (anObject instanceofString) {6 String anotherString =(String)anObject;7 int n =value.length;8 if (n ==anotherString.value.length) {9 char v1[] =value;10 char v2[] =anotherString.value;11 int i = 0;12 while (n-- != 0) {13 if (v1[i] !=v2[i])14 return false;15 i++;16 }17 return true;18 }19 }20 return false;21 }

上述的代码大致表示的是：将两个字符串拆分成一个字符一个字符地对比，只有两个字符串的全部字符相等，才返回true，因此实现了比较两个String对象(对象类型)指向的值是否相等的功能。因此，此时我们明白了为什么 s1.equals(s3)为true。

那么现在的问题来了，String类型不是对象类型吗？对象类型不是不能使用==来进行比较吗？那为什么s1==s2会是true？

String常量池就出现在我们的讨论中了

为了减少在JVM中创建的字符串的数量，字符串类维护了一个字符串池，每当代码创建字符串常量时，JVM会首先检查字符串常量池。如果字符串已经存在池中，就会返回池中的实例引用。如果字符串不在池中，就会实例化一个字符串并且放到池中。也就是说，如以下代码

String s1 = "123";

String s2 = "123";

创建s1字符串后，在字符串常量池中就存在一个实例“123”，当第二次创建字符串常量s2时，

由于s2对应的也是“123”，而String常量池中此时已经有“123”，所以就直接将s2指向"123"，在此过程中没有对象的新建。因此，实际上s1和s2是一个对象，所以自然s1==s2 为true；

下面有个思考题给读者好好思考：(也是容易被面试到经典问题)

1 String s1 = new String("你好") ;2 String s2 = new String("你好") ;

上述代码中，一共创建几个String对象？答案：3个。好好思考。(编译期Constant Pool(常量池)中创建1个,运行期heap(堆)中创建2个)

更多关于常量池的内容，请参考：

2.“equals”、“hashCode”：

先看一段代码：

1 String s1 = "123";2 String s2 = new String("123");3 System.out.println("s1.equals(s2)? "+s1.equals(s2));//true4

5 //输出s1和s2的hashCode

6 System.out.println("s1,s2的hashCode分别为:");7 System.out.println("s1:"+s1.hashCode());//48690

8 System.out.println("s2:"+s2.hashCode());//486909

10 //创建一个HashSet

11 Set hashSet = new HashSet();12 hashSet.add(s1);//将s1加入集合hashSet

13 hashSet.add(s2);//将s2加入集合hashSet14

15 //遍历集合hashSet

16 System.out.println("存储在hashSet中的元素为:");17 Iterator it =hashSet.iterator();18 while(it.hasNext()) {19 System.out.println(it.next());20 }

运行结果：

1 s1.equals(s2)? true

2 s1,s2的hashCode分别为:3 s1:48690

4 s2:48690

5 存储在hashSet中的元素为:6 123

看了上面的代码和运行结果，首先我们先了解一下什么是hashCode？hashCode为什么会被设计出来？或者它有什么用处？

hashCode是jdk根据对象的地址或者字符串或者数字算出来的int类型的数值，public int hashCode() 返回该对象的哈希码值。本例中String中的hashCode()方法：

1 public inthashCode() {2 int h =hash;3 if (h == 0 && value.length > 0) {4 char val[] =value;5

6 for (int i = 0; i < value.length; i++) {7 h = 31 * h +val[i];8 }9 hash =h;10 }11 returnh;12 }

那么，hashCode值与equals是否有关系呢？答案是肯定的，如果使用equals()方法比较两个对象得到true，那么这两个对象的hashCode必须是相同的。

需要注意的是：这里所指的true是，使用Object类中的equals()方法比较两个对象得到的true。

这也就要求了当继承了Object类的一个类需要重写equals()方法来判断相等逻辑时，也要同时重写hashCode()方法来返回与equals()判断逻辑一致的hashCode值。String类重写了equals方法，所以当equals判断相等时，必须返回给两个对象相同的hashCode值。所以：上述代码中s1和s2的hashCode均为48690。

hashCode的设计目的是为了提高哈希表的性能，那么它是如何提高性能的呢？以上面代码创建的hashSet为例，讲述这个过程：

HashSet继承了Set接口，在HashSet中不允许出现重复对象。在HashSet是怎样判断元素是否重复呢？这就是该问题的关键所在，在Java集合中，判断两个对象是否相等的规则是：

1)先判断两个对象的hashCode是否相等，如果不相等，那么就认为两个对象不相等，就可以往HashSet中加入这两个对象；如果hashCode相等，那么要进行第二步；

2)再使用equals方法判断两个对象相等，如果相等，则说明两个对象相等，HashSet中不允许出现重复对象，例如上述代码：即使显示地给HashSet加入了s1和s2，但是我们发现遍历结果并没有输出两次“123”，仅有一次。

看到这里，有的人可能会迷惑，在判断对象是否相等时equals和hashCode哪个是主要判断标准？很显然是equals。因此总结equals()与hashCode的关系是：

1)hashCode相等的两个对象，equals()返回的不一定是true。

2)equals()返回为true时，hashCode一定相等。

当HashSet中元素比较多，或者重写equals()方法比较复杂时，每次往HashSet中加入一个元素，都要使用equals方法会使效率非常低，而直接先判断hashCode是否相等，判断hashCode是否相等就像一道堤坝先拦住了部分洪水，剩下来的洪水由另一个堤坝equals()拦截，大大提高了效率。

3.String类型传参

先看一段代码：

1 public static voidmain(String[] args) {2 String s1 = "123";3 String s2 = new String("123");4

5 //输出将s1、s2作为参数传递后的值

6 changeString(s1);7 changeString(s2);8 System.out.println("将s1传入changeString()方法后，s1:"+s1);9 System.out.println("将s2传入changeString()方法后，s2:"+s2);10 }11

12 //定义一个改变传入参数(String类型)的方法

13 public staticString changeString(String s) {14 s = "我被改变了!";15 returns;16 }

运行结果:

1 将s1传入changeString()方法后，s1:123

2 将s2传入changeString()方法后，s2:123

运行结果告诉我们，尽管changeString()传入的参数是String类型(对象类型)，但是想通过此方法尝试将s1，s2改变后，发现s1，s2并没有发生变化。

Java中传递的永远是值，我们知道，当传入的参数是基本类型时，其实只是把值赋值给了形参，无论在方法体中如何对形参操作，原来的基本类型对应的值不会发生任何变化，比如：如下代码

1 public static voidmain(String[] args) {2

3 int a = 0;4 change(a);5 System.out.println("a经过change方法后，a仍然是："+a);6 }7

8 public static int change(inta) {9 a = 666;10 returna ;11 }

只是将 0 赋值给了 形参a而已。

运行结果：

1 a经过change方法后，a仍然是：0

我们也知道，当传入参数是对象类型时，相当于把对象的地址赋值给了形参，对形参进行操作即是对实参操作，实参会发生改变。如：

1 public static voidmain(String[] args) {2 int[] a = new int[3];//定义一个长度为3的数组,数组为对象类型(引用类型)3 //为该数组中的每个元素赋值为1;

4 for(int i =0;i

8 System.out.println("a[]传入change()方法前：");9 //遍历数组中的元素

10 for(inti:a) {11 System.out.println(i);12 }13

14 change(a);15 System.out.println("将a[]传入change()方法后：");16 //遍历数组中的元素

17 for(inti:a) {18 System.out.println(i);19 }20 }21

22 public static int[] change(int[]a) {23 //为形参中的数组赋值为2;

24 for(int i=0;i

运行结果：

1 a[]传入change()方法前：2 1

3 1

4 1

5 将a[]传入change()方法后：6 2

7 2

8 2

那么问题来了，同样作为对象类型的String类对象，为什么就不满足当传参是对象类型时的规则呢？请打开String类的API：

1 public final classString2 implements java.io.Serializable, Comparable, CharSequence {3 ......4 ......

我们可以发现，修饰String类的前面有个final关键字，该final关键字有什么用？

用final修饰String类，表明String类是immutable(不可变的)，当实例被创建时就会被初始化，并且无法修改实例信息。说点容易理解的：比如

当我们定义了：String s1 = "abcd"; 对s进行改变，将其改变为：s1 =  "abcdef"时，实际上并没有在常量池中修改原来s的值，而是重新在常量池中重新加入一个"abcdef"，而此时s1指向"abcdef"。如下图：

好了 ，就这么多。各位加油！

2018/11/29 22:45:13

转载请注明出处！