Comparable接口：针对排序list

 

问题：上面的算法根据什么确定容器中对象的“大小”顺序？

所有可以“排序”的类都实现了java.lang.Comparable接口，Comparable接口中只有一个方法

Publicint compareTo(Object obj)

返回0：表示this==obj

返回正数：表示this>obj

返回负数：表示this<obj

实现了Comparable接口的类通过实现comparaTo方法从而确定该对象的排序方式


equals()与hashCode()：保证不重复

 

由来：

 

    要想保证元素不重复，可两个元素是否重复应该依据什么来判断呢？这就是Object.equals方法了。但是，如果每增加一个元素就检查一次，那么当元素很多时，后添加到集合中的元素比较的次数就非常多了。也就是说，如果集合中现在已经有1000个元素，那么第1001个元素加入集合时，它就要调用1000次equals方法。这显然会大大降低效率。  

    于是，Java采用了哈希表的原理。哈希算法也称为散列算法，是将数据依特定算法直接指定到一个地址上。

    这样一来，当集合要添加新的元素时，先调用这个元素的hashCode方法，就一下子能定位到它应该放置的物理位置上。如果这个位置上没有元素，它就可以直接存储在这个位置上，不用再进行任何比较了；如果这个位置上已经有元素了，就调用它的equals方法与新元素进行比较，相同的话就不存了，不相同就散列其它的地址。所以这里存在一个冲突解决的问题。这样一来实际调用equals方法的次数就大大降低了，几乎只需要一两次。

 

规则：

 

      所以，Java对于eqauls方法和hashCode方法是这样规定的：


      1.如果两个对象相同，那么它们的hashCode值一定要相同；

      2.如果两个对象的hashCode相同，它们并不一定相同（这里说的对象相同指的是用eqauls方法比较）。如不按要求去做了，会发现相同的对象可以出现在Set集合中，同时，增加新元素的效率会大大下降。

      3.equals()相等的两个对象，hashcode()一定相等；equals()不相等的两个对象，却并不能证明他们的hashcode()不相等。

       

    在object类中，hashcode()方法是本地方法，返回的是对象的地址值，而object类中的equals()方法比较的也是两个对象的地址值，如果equals()相等，说明两个对象地址值也相等，当然hashcode()也就相等了；

    在String类中，equals()返回的是两个对象内容的比较，当两个对象内容相等时Hashcode()方法根据String类的重写代码的分析，也可知道hashcode()返回结果也会相等。

    以此类推，可以知道Integer、Double等封装类中经过重写的equals()和hashcode()方法也同样适合于这个原则。当然没有经过重写的类，在继承了object类的equals()和hashcode()方法后，也会遵守这个原则。

 

总结：

 

    hashCode()方法被用来获取给定对象的唯一整数。这个整数被用来确定对象被存储在HashTable类似的结构中的位置。默认的，Object类的hashCode()方法返回这个对象存储的内存地址的编号。 hashCode()和equals()定义在Object类中，这个类是所有java类的基类，所以所有的java类都继承这两个方法。

    如果我们不重写这两个方法，将几乎不遇到任何问题，但是有的时候程序要求我们必须改变一些对象的默认实现。

 

举例说明：

[java]  view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. public class TestString{  
  2.     public static void main(String[] args){  
  3.         String s1="Hello";  
  4.         String s2="World";  
  5.         String s3="Hello";  
  6.         System.out.println(s1 == s3);  
  7.           
  8.         s1=new String("hello");  
  9.         s2=new String("hello");  
  10.         System.out.println(s1 == s2);  
  11.         System.out.println(s1.equals(s2));  
  12.           
  13.           
  14.         }  
  15. }  



以上的正确执行是因为我们已经默认重写了String类的equals()方法和hashCode()方法。但是如果是Object类呢？

[java]  view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. import java.util.HashSet;  
  2. import java.util.Set;  
  3.   
  4. public class TestEquals1{  
  5.     public static void main(String[] args){  
  6.             Cat cl=new Cat(1,2,3);  
  7.             Cat c2=new Cat(1,2,3);  
  8.             System.out.println(cl==c2);  
  9.             System.out.println(cl.equals(c2));  
  10.               
  11.         }  
  12.     }  
  13.   
  14. class Cat{  
  15.           
  16.         int color,height,weight;  
  17.         public Cat(int color,int height,int weight){  
  18.               
  19.             this.color=color;  
  20.             this.height=height;  
  21.             this.weight=weight;  
  22.             }  
  23.           
  24. }  



毫无疑问，上面的程序将输出false，但是，事实上上面两个对象代表的是通过一个cat。真正的商业逻辑希望我们返回true。重写equals()方法！


[java]  view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. public class TestEquals{  
  2.     public static void main(String[] args){  
  3.             Cat cl=new Cat(1,2,3);  
  4.             Cat c2=new Cat(1,2,3);  
  5.             System.out.println(cl==c2);  
  6.             System.out.println(cl.equals(c2));  
  7.         }  
  8.     }  
  9.   
  10. class Cat{  
  11.           
  12.         int color,height,weight;  
  13.         public Cat(int color,int height,int weight){  
  14.               
  15.             this.color=color;  
  16.             this.height=height;  
  17.             this.weight=weight;  
  18.             }  
  19.         public boolean equals(Object obj){  
  20.             if(obj==null)return false;  
  21.             else{  
  22.                 if(obj instanceof Cat){  
  23.                     Cat c=(Cat)obj;  
  24.                     if(c.color==this.color && c.height==this.height && c.weight==this.weight){  
  25.                         return true;  
  26.                         }  
  27.                     }  
  28.                 }  
  29.                 return false;  
  30.             }  
  31.     }  




So are we done?没有，让我们换一种测试方法来看看。

上面的程序输出的结果是两个。如果两个cat对象equals返回true，Set中应该只存储一个对象才对，而且System.out.println(cat.contains(newCat(1,2,3)));判断是否存在时，结果输出为false，如图：




那么问题在哪里呢？



我们忘掉了第二个重要的方法hashCode()。就像JDK的Javadoc中所说的一样，如果重写equals()方法必须要重写hashCode()方法。我们加上下面这个方法，程序将执行正确。


[java]  view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. public int hashCode()  
  2.      {  
  3.       final int PRIME =31;  
  4.       int result = 1;  
  5.       result = PRIME * result ;  
  6.       return result;  
  7. }  





再总结：


    以上这些都是针对容器来说的（如何判断set中不重复，如何判断list中的顺序），当然最主要的是解释为什么重写equals()方法必须要重写hashCode()方法的问题。

    根据一个类的equals方法（改写后），两个截然不同的实例有可能在逻辑上是相等的，但是，根据Object.hashCode方法，它们仅仅是两个对象。因此，违反了“相等的对象必须具有相等的散列码”。

    所以只要重写了equals()，一定要重写hashCode，否则Hash表都会失效，工作不正常。即便你用equals方法比较得到两个对象是相等的结论那你也得不到相同的哈希码

 

    即如果cat类只重写了equals（），hashcode没有被重写，加入元素时使用的hashcode（）是继承于set<-collection<-object的，所以计算的hashcode值不同，存储位置不同，则认为元素不相同，也就能明白为什么上面的判断是否存在（System.out.println(cat.contains(newCat(1,2,3)))）时输入的结果为false了。

Logo
向您推荐>>Eolink开发者社区

权威｜前沿｜技术｜干货｜国内首个API全生命周期开发者社区

更多推荐

ELK实现containerd的容器日志采集展示【基于logging的全栈监测】

企业级ELK Stack构建介绍

avatar 云原生

深入理解 Mocha 测试框架：从零实现一个 Mocha

前言什么是自动化测试自动化测试在很多团队中都是Devops环节中很难执行起来的一个环节，主要原因在于测试代码的编写工作很难抽象，99%的场景都需要和业务强绑定，而且写测试代码的编写工作量往往比编写实际业务代码的工作量更多。在一些很多业务场景中投入产出比很低，适合写自动化测试的应该是那些中长期业务以及一些诸如组件一样的基础库。自动化测试是个比较大的概念，其中分类也比较多，比如单元测试，端对端测试，集

avatar 云原生

(20200916 Solved)docker-compose up创建容器自动退出

问题描述如题，创建容器后自动退出了。并且docker start container无效解决方案原因是缺失了控制终端的配置，需要在docker-compose.yml中增加tty:true ，有时候这样也不行，需要再增加一个command:/bin/bash，命令不一定是这个，需要是一个不会退出的命令，然后用-d后台启动容器。Referencesdocker-compose启动容器后自动退出...

avatar 云原生