关于Java中equals()和hashCode()的用法笔记。

【Java】如何重写hashCode()和equals()方法 文章目录1. 如何重写hashCode()方法2. 如何重写equals()方法 如之前提到的对hashCode()的分析: 【Java】hashCode特性、算法和作用 例子代码中的类: class Worker { private String name; private int age; private double salary; //...略 } 1. 如何重写hashCode... 阅读详情

今天看了一片出自百度文库的一篇关于java对象中equals()和hashcode()函数的用法,感觉很清晰,于是就把他整理了一下。

百度文库地址:http://wenku.baidu.com/view/9070f05c312b3169a451a4af.html

有许多人学了很长时间的Java,但一直不明白hashCode方法的作用,我来解释一下吧。首先,想要明白hashCode的作用,你必须要先知道Java中的集合。  总的来说,Java中的集合(Collection)有两类,一类是List,再有一类是Set。

——————————————————————————————————

PS:关于java的集合框架在这多说两句:

Java2的集合框架,主要有三种:List、Set和Map,其中List和Set是继承Collection,需要注意的是,这里的 Collection、List、Set和Map都是接口(Interface),不是具体的类实现。

常用集合类的继承结构如下:
Collection<--List<--Vector
Collection<--List<--ArrayList
Collection<--List<--LinkedList
Collection<--Set<--HashSet
Collection<--Set<--HashSet<--LinkedHashSet
Collection<--Set<--SortedSet<--TreeSet
Map<--SortedMap<--TreeMap
Map<--HashMap 

List
List是有序的Collection,使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引(元素在List中的位置,类似于数组下 >标)来访问List中的元素,这类似于Java的数组。 

Set
Set是一种不包含重复的元素的无序Collection。 

Map
Map 是一种把键对象和值对象进行关联的容器,而一个值对象又可以是一个Map,依次类推,这样就可形成一个多级映射。对于键对象来说,像Set一样,一个 Map容器中的键对象不允许重复,这是为了保持查找结果的一致性;如果有两个键对象一样,那你想得到那个键对象所对应的值对象时就有问题了,可能你得到的并不是你想的那个值对象,结果会造成混乱,所以键的唯一性很重要,也是符合集合的性质的

一、几个常用类的区别
1.ArrayList: 元素单个,效率高,多用于查询
2.Vector: 元素单个,线程安全,多用于查询
3.LinkedList:元素单个,多用于插入和删除
4.HashMap: 元素成对,元素可为空
5.HashTable: 元素成对,线程安全,元素不可为空 

三、Collections和Arrays
在 Java集合类框架里有两个类叫做Collections(注意,不是Collection!)和Arrays,这是JCF里面功能强大的工具,但初学者往往会忽视。按JCF文档的说法,这两个类提供了封装器实现(Wrapper Implementations)、数据结构算法和数组相关的应用

——————————————————————————————————

你知道它们的区别吗?前者集合内的元素是有序的,元素可以重复;后者元素无序,但元素不可重复。那么这里就有一个比较严重的问题了:要想保证元素不重复,可两个元素是否重复应该依据什么来判断呢?这就是Object.equals方法了。但是,如果每增加一个元素就检查一次,那么当元素很多时,后添加到集合中的元素比较的次数就非常多了。也就是说,如果集合中现在已经有1000个元素,那么第1001个元素加入集合时,它就要调用1000次equals方法。这显然会大大降低效率。    于是,Java采用了哈希表的原理。哈希(Hash)实际上是个人名,由于他提出一哈希算法的概念,所以就以他的名字命名了。哈希算法也称为散列算法,是将数据依特定算法直接指定到一个地址上。如果详细讲解哈希算法,那需要更多的文章篇幅,我在这里就不介绍了。初学者可以这样理解,hashCode方法实际上返回的就是对象存储的物理地址(实际可能并不是)。    这样一来,当集合要添加新的元素时,先调用这个元素的hashCode方法,就一下子能定位到它应该放置的物理位置上。如果这个位置上没有元素,它就可以直接存储在这个位置上,不用再进行任何比较了;如果这个位置上已经有元素了,就调用它的equals方法与新元素进行比较,相同的话就不存了,不相同就散列其它的地址。所以这里存在一个冲突解决的问题。这样一来实际调用equals方法的次数就大大降低了,几乎只需要一两次。    所以,Java对于eqauls方法和hashCode方法是这样规定的:1、如果两个对象相同,那么它们的hashCode值一定要相同;2、如果两个对象的hashCode相同,它们并不一定相同    上面说的对象相同指的是用eqauls方法比较。    你当然可以不按要求去做了,但你会发现,相同的对象可以出现在Set集合中。同时,增加新元素的效率会大大下降。
java中hashcode()和equals()的详解

1. 首先equals()和hashcode()这两个方法都是从object类中继承过来的。
equals()方法在object类中定义如下:

public boolean equals(Object obj) {
return (this == obj);
} 

很明显是对两个对象的地址值进行的比较(即比较引用是否相同)。但是我们必需清楚,当String 、Math、还有Integer、Double。。。。等这些封装类在使用equals()方法时,已经覆盖了object类的equals()方法。比如在String类中如下:

public boolean equals(Object anObject) {
if (this == anObject) {
    return true;
}
if (anObject instanceof String) {
    String anotherString = (String)anObject;
    int n = count;
    if (n == anotherString.count) {
char v1[] = value;
char v2[] = anotherString.value;
int i = offset;
int j = anotherString.offset;
while (n-- != 0) {
    if (v1[i++] != v2[j++])
return false;
}
return true;
    }
}
return false;
} 

很明显,这是进行的内容比较,而已经不再是地址的比较。依次类推Double、Integer、Math。。。。等等这些类都是重写了equals()方法的,从而进行的是内容的比较。当然了基本类型是进行值的比较,这个没有什么好说的。
我们还应该注意,Java语言对equals()的要求如下,这些要求是必须遵循的:
• 对称性:如果x.equals(y)返回是“true”,那么y.equals(x)也应该返回是“true”。
• 反射性:x.equals(x)必须返回是“true”。
• 类推性:如果x.equals(y)返回是“true”,而且y.equals(z)返回是“true”,那么z.equals(x)也应该返回是“true”。
• 还有一致性:如果x.equals(y)返回是“true”,只要x和y内容一直不变,不管你重复x.equals(y)多少次,返回都是“true”。
• 任何情况下,x.equals(null),永远返回是“false”;x.equals(和x不同类型的对象)永远返回是“false”。
以上这五点是重写equals()方法时,必须遵守的准则,如果违反会出现意想不到的结果,请大家一定要遵守。
2. 其次是hashcode() 方法,在object类中定义如下:

public native int hashCode(); 
说明是一个本地方法,它的实现是根据本地机器相关的。当然我们可以在自己写的类中覆盖hashcode()方法,比如String、Integer、Double。。。。等等这些类都是覆盖了hashcode()方法的。例如在String类中定义的hashcode()方法如下:
public int hashCode() {
int h = hash;
if (h == 0) {
    int off = offset;
    char val[] = value;
    int len = count;

            for (int i = 0; i < len; i++) {
                h = 31*h + val[off++];
            }
            hash = h;
        }
        return h;
} 
解释一下这个程序(String的API中写到):
s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]
使用 int 算法,这里 s[i] 是字符串的第 i 个字符,n 是字符串的长度,^ 表示求幂。(空字符串的哈希码为 0。)

3.这里我们首先要明白一个问题:
equals()相等的两个对象,hashcode()一定相等;
equals()不相等的两个对象,却并不能证明他们的hashcode()不相等。换句话说,equals()方法不相等的两个对象,hashcode()有可能相等。(我的理解是由于哈希码在生成的时候产生冲突造成的)。
反过来:hashcode()不等,一定能推出equals()也不等;hashcode()相等,equals()可能相等,也可能不等。解释下第3点的使用范围,我的理解是在object、String等类中都能使用。在object类中,hashcode()方法是本地方法,返回的是对象的地址值,而object类中的equals()方法比较的也是两个对象的地址值,如果equals()相等,说明两个对象地址值也相等,当然hashcode()也就相等了;在String类中,equals()返回的是两个对象内容的比较,当两个对象内容相等时,
Hashcode()方法根据String类的重写(第2点里面已经分析了)代码的分析,也可知道hashcode()返回结果也会相等。以此类推,可以知道Integer、Double等封装类中经过重写的equals()和hashcode()方法也同样适合于这个原则。当然没有经过重写的类,在继承了object类的equals()和hashcode()方法后,也会遵守这个原则。

4.谈到hashcode()和equals()就不能不说到hashset,hashmap,hashtable中的使用,具体是怎样呢,请看如下分析:
Hashset是继承Set接口,Set接口又实现Collection接口,这是层次关系。那么hashset是根据什么原理来存取对象的呢?
在hashset中不允许出现重复对象,元素的位置也是不确定的。在hashset中又是怎样判定元素是否重复的呢?这就是问题的关键所在,经过一下午的查询求证终于获得了一点启示,和大家分享一下,在java的集合中,判断两个对象是否相等的规则是:
1),判断两个对象的hashCode是否相等
      如果不相等,认为两个对象也不相等,完毕
      如果相等,转入2)
(这一点只是为了提高存储效率而要求的,其实理论上没有也可以,但如果没有,实际使用时效率会大大降低,所以我们这里将其做为必需的。后面会重点讲到这个问题。)
2),判断两个对象用equals运算是否相等
      如果不相等,认为两个对象也不相等
      如果相等,认为两个对象相等(equals()是判断两个对象是否相等的关键)
为什么是两条准则,难道用第一条不行吗?不行,因为前面已经说了,hashcode()相等时,equals()方法也可能不等,所以必须用第2条准则进行限制,才能保证加入的为非重复元素。
比如下面的代码:

public static void main(String args[]){
String s1=new String("zhaoxudong");
String s2=new String("zhaoxudong");
System.out.println(s1==s2);//false
System.out.println(s1.equals(s2));//true
System.out.println(s1.hashCode());//s1.hashcode()等于s2.hashcode()
System.out.println(s2.hashCode());
Set hashset=new HashSet();
hashset.add(s1);
hashset.add(s2);
/*实质上在添加s1,s2时,运用上面说到的两点准则,可以知道hashset认为s1和s2是相等的,是在添加重复元素,所以让s2覆盖了s1;*/
Iterator it=hashset.iterator();
            while(it.hasNext())
            {
             System.out.println(it.next());
            } 

最后在while循环的时候只打印出了一个”zhaoxudong”。
输出结果为:
            false
            true
            -967303459
            -967303459

这是因为String类已经重写了equals()方法和hashcode()方法,所以在根据上面的第1.2条原则判定时,hashset认为它们是相等的对象,进行了重复添加。
但是看下面的程序:

import java.util.*;
public class HashSetTest
{
   public static void main(String[] args)
    {
                 HashSet hs=new HashSet();
                 hs.add(new Student(1,"zhangsan"));
                 hs.add(new Student(2,"lisi"));
                 hs.add(new Student(3,"wangwu"));
                 hs.add(new Student(1,"zhangsan"));
 
                 Iterator it=hs.iterator();
                 while(it.hasNext())
                 {
                        System.out.println(it.next());
                 }
     }
}
class Student
   {
     int num;
     String name;
     Student(int num,String name)
                {
                this.num=num;
                 this.name=name;
                 }
              public String toString()
                {
                    return num+":"+name;
                 }
           }      

输出结果为:

                   1:zhangsan
                   1:zhangsan
                   3:wangwu
                   2:lisi

问题出现了,为什么hashset添加了相等的元素呢,这是不是和hashset的原则违背了呢?回答是:没有
因为在根据hashcode()对两次建立的new Student(1,"zhangsan")对象进行比较时,生成的是不同的哈希码值,所以hashset把他当作不同的对象对待了,当然此时的equals()方法返回的值也不等(这个不用解释了吧)。那么为什么会生成不同的哈希码值呢?上面我们在比较s1和s2的时候不是生成了同样的哈希码吗?原因就在于我们自己写的Student类并没有重新自己的hashcode()和equals()方法,所以在比较时,是继承的object类中的hashcode()方法,呵呵,各位还记得object类中的hashcode()方法比较的是什么吧!!
它是一个本地方法,比较的是对象的地址(引用地址),使用new方法创建对象,两次生成的当然是不同的对象了(这个大家都能理解吧。。。),造成的结果就是两个对象的hashcode()返回的值不一样。所以根据第一个准则,hashset会把它们当作不同的对象对待,自然也用不着第二个准则进行判定了。那么怎么解决这个问题呢??
答案是:在Student类中重新hashcode()和equals()方法。
例如:

class Student
{
int num;
String name;
Student(int num,String name)
{
            this.num=num;
            this.name=name;
}
public int hashCode()
{
            return num*name.hashCode();
}
public boolean equals(Object o)
{
            Student s=(Student)o;
            return num==s.num && name.equals(s.name);
}
public String toString()
{
            return num+":"+name;
}
} 

根据重写的方法,即便两次调用了new Student(1,"zhangsan"),我们在获得对象的哈希码时,根据重写的方法hashcode(),获得的哈希码肯定是一样的(这一点应该没有疑问吧)。
当然根据equals()方法我们也可判断是相同的。所以在向hashset集合中添加时把它们当作重复元素看待了。所以运行修改后的程序时,我们会发现运行结果是:

                   1:zhangsan
                   3:wangwu
                   2:lisi

可以看到重复元素的问题已经消除。
关于在hibernate的pojo类中,重新equals()和hashcode()的问题:
1),重点是equals,重写hashCode只是技术要求(为了提高效率)
2),为什么要重写equals呢,因为在java的集合框架中,是通过equals来判断两个对象是否相等的
3),在hibernate中,经常使用set集合来保存相关对象,而set集合是不允许重复的。我们再来谈谈前面提到在向hashset集合中添加元素时,怎样判断对象是否相同的准则,前面说了两条,其实只要重写equals()这一条也可以。
但当hashset中元素比较多时,或者是重写的equals()方法比较复杂时,我们只用equals()方法进行比较判断,效率也会非常低,所以引入了hashcode()这个方法,只是为了提高效率,但是我觉得这是非常有必要的(所以我们在前面以两条准则来进行hashset的元素是否重复的判断)。
比如可以这样写:

public int hashCode(){
   return  1;}//等价于hashcode无效 
这样做的效果就是在比较哈希码的时候不能进行判断,因为每个对象返回的哈希码都是1,每次都必须要经过比较equals()方法后才能进行判断是否重复,这当然会引起效率的大大降低。
我有一个问题,如果像前面提到的在hashset中判断元素是否重复的必要方法是equals()方法(根据网上找到的观点),但是这里并没有涉及到关于哈希表的问题,可是这个集合却叫hashset,这是为什么??
我想,在hashmap,hashtable中的存储操作,依然遵守上面的准则。所以这里不再多说。这些是今天看书,网上查询资料,自己总结出来的,部分代码和语言是引述,但是千真万确是自己总结出来的。有错误之处和不详细不清楚的地方还请大家指出,我也是初学者,所以难免会有错误的地方,希望大家共同讨论。 


1. '=='是用来比较两个变量(基本类型和对象类型)的值是否相等的, 如果两个变量是基本类型的,那很容易,直接比较值就可以了。如果两个变量是对象类型的,那么它还是比较值,只是它比较的是这两个对象在栈中的引用(即地址)。
对象是放在堆中的,栈中存放的是对象的引用(地址)。由此可见'=='是对栈中的值进行比较的。如果要比较堆中对象的内容是否相同,那么就要重写equals方法了。
2. Object类中的equals方法就是用'=='来比较的,所以如果没有重写equals方法,equals和==是等价的。
通常我们会重写equals方法,让equals比较两个对象的内容,而不是比较对象的引用(地址)因为往往我们觉得比较对象的内容是否相同比比较对象的引用(地址)更有意义。
3. Object类中的hashCode是返回对象在内存中地址转换成的一个int值(可以就当做地址看)。所以如果没有重写hashCode方法,任何对象的hashCode都是不相等的。通常在集合类的时候需要重写hashCode方法和equals方法,因为如果需要给集合类(比如:HashSet)添加对象,那么在添加之前需要查看给集合里是否已经有了该对象,比较好的方式就是用hashCode。
4. 注意的是String、Integer、Boolean、Double等这些类都重写了equals和hashCode方法,这两个方法是根据对象的内容来比较和计算hashCode的。(详细可以查看jdk下的String.java源代码),所以只要对象的基本类型值相同,那么hashcode就一定相同。
5. equals()相等的两个对象,hashcode()一般是相等的,最好在重写equals()方法时,重写hashcode()方法; equals()不相等的两个对象,却并不能证明他们的hashcode()不相等。换句话说,equals()方法不相等的两个对象,hashcode()有可能相等。 反过来:hashcode()不等,一定能推出equals()也不等;hashcode()相等,equals()可能相等,也可能不等。在object类中,hashcode()方法是本地方法,返回的是对象的引用(地址值),而object类中的equals()方法比较的也是两个对象的引用(地址值),如果equals()相等,说明两个对象地址值也相等,当然hashcode()也就相等了。
以下是测试代码。
Java代码    

public class Equals_HashCode {  
   public static void main(String[] args) {          
          String a = new String("str");  
          String b = new String("str");  
          System.out.println(a==b);  
          System.out.println(a.equals(b));  
          System.out.println(a.hashCode());  
          System.out.println(b.hashCode());  
          // 输出 false true 114225 114225  
          class A{  
              String str;  
              int i;  
              public A(String str, int i) {  
                  super();  
                  this.str = str;  
                  this.i = i;  
              }  
          }  
          A aA = new A("str",1);  
          A bA = new A("str",1);  
          System.out.println(aA==bA);  
          System.out.println(aA.equals(bA));  
          System.out.println(aA.hashCode());  
          System.out.println(bA.hashCode());  
          // 输出 false false 6413875 21174459  
          class B{  
              String str;  
              public B(String str){  
                  this.str = str;  
              }  
          }  
          B aB = new B("str");  
          B bB = new B("str");  
          System.out.println(aB==bB);  
          System.out.println(aB.equals(bB));  
          System.out.println(aB.hashCode());  
          System.out.println(bB.hashCode());  
          // 输出 false false 827574 17510567  
          class C{  
              int i;  
              public C(int i){  
                  this.i = i;  
              }  
          }  
          C aC = new C(1);  
          C bC = new C(1);  
         System.out.println(aC==bC);  
          System.out.println(aC.equals(bC));  
          System.out.println(aC.hashCode());  
          System.out.println(bC.hashCode());  
          //输出 false false 27744459  28737396  
     }  
    
 }  
   
java中equal和==的比较
java中equals方法和“==”的区别:

equals 方法是 java.lang.Object 类的方法。

有两种用法说明:

(1)对于字符串变量来说,使用“==”和“equals()”方法比较字符串时,其比较方法不同。

“==”比较两个变量本身的值,即两个对象在内存中的首地址。

“equals()”比较字符串中所包含的内容是否相同。

比如:

String s1,s2,s3 = "abc", s4 ="abc" ;

s1 = new String("abc");

s2 = new String("abc"); 
那么:

s1==s2 是 false //两个变量的内存地址不一样,也就是说它们指向的对象不 一样,

故不相等。

s1.equals(s2) 是 true //两个变量的所包含的内容是abc,故相等。

注意(1):

如果: StringBuffer s1 = new StringBuffer("a");

StringBuffer s2 = new StringBuffer("a");

结果: s1.equals(s2) //是false

解释:StringBuffer类中没有重新定义equals这个方法,因此这个方法就来自Object类,

而Object类中的equals方法是用来比较“地址”的,所以等于false.

注意(2):

对于s3和s4来说,有一点不一样要引起注意,由于s3和s4是两个字符

串常量所生成的变量,其中所存放的内存地址是相等的,

所以s3==s4是true(即使没有s3=s4这样一个赋值语句)

(2)对于非字符串变量来说,"=="和"equals"方法的作用是相同的都是用来比较其

对象在堆内存的首地址,即用来比较两个引用变量是否指向同一个对象。

比如:
class A

{

A obj1 = new A();

A obj2 = new A();

} 

那么:obj1==obj2是false

obj1.equals(obj2)是false

但是如加上这样一句:obj1=obj2;

那么 obj1==obj2 是true

obj1.equals(obj2) 是true

总之:equals方法对于字符串来说是比较内容的,而对于非字符串来说是比较

其指向的对象是否相同的。

== 比较符也是比较指向的对象是否相同的也就是对象在对内存中的的首地址。

String类中重新定义了equals这个方法,而且比较的是值,而不是地址。所以是true。

关于equals与==的区别从以下几个方面来说:

(1)如果是基本类型比较,那么只能用==来比较,不能用equals

比如:
public class TestEquals {

public static void main(String[] args)

{

int a = 3;

int b = 4;

int c = 3;

System.out.println(a == b);//结果是false

System.out.println(a == c);//结果是true

System.out.println(a.equals(c));//错误,编译不能通过,equals方法

//不能运用与基本类型的比较

}

} 


(2)对于基本类型的包装类型,比如Boolean、Character、Byte、Shot、Integer、Long、Float、Double等的引用变量,==是比较地址的,而equals是比较内容的。比如:
public class TestEquals {

public static void main(String[] args)

{ Integer n1 = new Integer(30);

Integer n2 = new Integer(30);

Integer n3 = new Integer(31);

System.out.println(n1 == n2);//结果是false 两个不同的Integer对象,故其地址不同,

System.out.println(n1 == n3);//那么不管是new Integer(30)还是new Integer(31) 结果都显示false

System.out.println(n1.equals(n2));//结果是true 根据jdk文档中的说明,n1与n2指向的对象中的内容是相等的,都是30,故equals比较后结果是true

System.out.println(n1.equals(n3));//结果是false 因对象内容不一样,一个是30一个是31

}

}


这是Integer的实例,如果是其他的比如Double、Character、Float等也一样。

(3)注意:对于String(字符串)、StringBuffer(线程安全的可变字符序列)、StringBuilder(可变字符序列)这三个类作进一步的说明。

(a)首先,介绍String的用法,请看下面的实例:

public class TestEquals {

public static void main(String[] args) {

String s1 = "123";

String s2 = "123";

String s3 = "abc";

String s4 = new String("123");

String s5 = new String("123");

String s6 = new String("abc");

System.out.println(s1 == s2);//(1)true

System.out.println(s1.equals(s2));//(2)true

System.out.println(s1 == s3);//(3)flase

System.out.println(s1.equals(s3));//(4)flase

System.out.println(s4 == s5);//(5)flase

System.out.println(s4.equals(s5));//(6)true

System.out.println(s4 == s6);//(7)flase

System.out.println(s4.equals(s6));//(8)flase

System.out.println(s1 == s4);//(9)false

System.out.println(s1.equals(s4));//(10)true

}

}

答案解释:s1与s2分别指向由字符串常量”123” 创建的对象,在常量池中,只有一个对象,内容为123,有两个引用s1和s2指向这个对象,故这两个引用变量所指向的地址是相同的,因而(1)处的运行结果为true,又因为s1.equals(s2)是比较s1和s2所指向的对象的内容是否相等,而我们知道这两个对象的内容都是字符串常量”123”,故标记(2)处的运行结果是true。

用同样的方法分析,s1和s3所指向的对象不一样,内容也不一样,故标记(3)和(4)处运行结果是false。

再看看s4和s5,这两个引用变量所指向的对象的内容都是一样的(内容都是123),但是这两个对象是用new操作符创建处类的,是在内存中分配两块空间给这两个对象的,因而这两个对象的内存地址不一样,故事两个不同的对象,标记(5)处的s4 == s5 运行结果为false,但是内容一样,故标记(6)处的s4.equals(s5)运行结果为true。同理,s4和s6所指向的对象地址不同,内容也不相同。故标记(7)(8)处运行结果为false。

s1和s4分别指向两个不同的对象(之所以这样称呼,是因为这两个对象在内存中的地址不相同,故而对象不相同),故标记为(9)处的s1 == s4运行结果为false,而标记为(10)处的s1.equals(s4)运行结果疑问:乍一看结果,有点惊讶,为什么不是true呢,不是说 equals方法是比较内容的吗?

解释:不错,如果在新类中被覆盖了equals方法,就可以用来比较内容的。但是在上面的例子中类Value并没有覆盖Object中的equals方法,而是继承了该方法,因此它就是被用来比较地址的,又v1和v2的所指向的对象不相同,故标记(1)处的v1.equals(v2)运行结果为false,标记为(2)处的v1 == v2运行结果也为false。 

——————————————————————————————————————————————

DONE,文章有点多,不过讲的很详细。

【git】git: ‘interpret-trailers’ is not a git command. See ‘git --help’ cents 7.6系统. yum源安装git最新版本是1.8.3 报错: git: 'interpret-trailers' is not a git command. See 'git --help'. cannot insert change-id line in .git/COMMIT_EDITMSG 解决: git add xxx git commit -m "xxx" 然后修改 vim .git/hooks/commit-msg #if test -n "${reviewurl}" ; th 阅读详情

相关推荐

abaqus wcm插件下载_Abaqus随机短纤维增强复合材料建模插件

文末附Abaqus随机短纤维增强复合材料建模插件下载链接前言短纤维增强复合材料相对于长纤维增强复合材料来说更容易制备,且短纤维的填充性能略有改善,可制造复杂产品,广泛应用于车辆、航空航天、建筑等行业,对短纤维增强复合材料进行细观力学分析,可对其宏观力学性能进行预测、分析破坏机理等。接下来对随机短纤维增强复合材料建模插件进行介绍。NO.1 【算法简介】难点一:此插件核心在于判断生成的纤维是...

weixin_39974882的博客 2834

【Java源码分析】String 字符串hashCode

hashCode hashCode() 方法用于返回字符串的哈希码。 字符串对象的哈希码根据以下公式计算: s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1] 使用 int 算法,这里 s[i] 是字符串的第 i 个字符的 ASCII 码,n 是字符串的长度,^ 表示求幂。空字符串的哈希值为 0。 语法 public int hashCode() 参数 无。 返回值 返回对象的哈希码值。 实例 public class Test { public

一片冰心 2203

若依(RuoYi)框架从零到部署:Spring Boot+Vue权限系统完整配置指南

在Java企业级应用开发中,Spring Boot作为构建微服务和单体应用的基石,极大地简化了项目初始化和配置流程。其核心原理在于通过自动配置和起步依赖,快速整合数据访问、安全认证、缓存等常用模块,显著提升开发效率。这一技术价值在需要快速构建后台管理系统的场景中尤为突出,例如权限管理、用户角色分配等通用需求。若依(RuoYi)框架正是基于Spring Boot和Vue.js的优秀实践,它封装了RBAC权限模型、代码生成器等高频功能,提供了开箱即用的解决方案。本文聚焦于若依框架的【环境配置】与【项目部署】,通

weixin_33984032的博客 457

String.hashCode()方法

hashCode() 方法用于返回字符串的哈希码。 字符串对象的哈希码根据以下公式计算: s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1] 所以相同的参数去获取hashCode时,获取到的hash值是一样的。

一片蓝蓝的云 1869

【数据中台】数据中台架构搭建百科全书

0、前言 当前,大部分企业不再建设从源数据采集到分析应用的烟囱式系统,更倾向于数据集中采集、存储,并应用分层建设。这种方式一方面有利于应用系统的快速部署,另一方面也保证了数据的集中管理与运营,体现数据的资产、资源属性。 数据中台的出现弥补了数据开发和应用开发之间由于开发速度不匹配而出现的响应力不足等缺陷问题。 数据中台是国内学者提出的概念,起始于阿里的“大中台、小前台”概念。阿里的中台是从管理的角度出发,以中台事业部集中数据搜索,技术及产品,数据共享等多个部门的功能。其他组织或企业建设数据中台不一定需

Sunny的专栏 8407

在Visual Studio中搭建Dynamo Python开发环境,效率飞一般的增长

在Visual Studio中搭建Dynamo Python开发环境,效率飞一般的增长

BIM的乐趣 1731

java hashcode返回值_Java String hashCode() 使用方法及示例

Java String hashCode() 使用方法及示例Java String hashCode()方法返回字符串的哈希码。字符串hashCode()方法的语法为:string.hashCode()在这里,string是String该类的一个对象。hashCode()参数不带任何参数hashCode()返回值返回字符串的哈希码,它是一个int值哈希码使用以下公式计算:s[0]*31(n-1)...

weixin_42524276的博客 1091

告别‘打架’的检测头:手把手教你用PyTorch实现YOLOv11解耦头(附完整代码)

本文详细解析了YOLOv11解耦检测头的创新设计与PyTorch实现,通过解耦分类和回归任务,显著提升目标检测性能。文章包含完整的代码实现、架构设计解析及工程调优技巧,帮助开发者深入理解并应用这一先进技术。

weixin_29031057的博客 301

String类的hashCode()方法源码分析

编译期间,字符串的最大长度不能超越65535个字节,即编译期间的String字符串的最大长度为65534个字节,不然就会编译报错。运行期间,String的最大长度就要看Integer.MAX_VALUE的值了,即:2^31 - 1个字节。不管怎样,String的最大长度就不能超过虚拟机当前最大内存设置。

weixin_53622554的博客 2051

具身智能四大技术路线:VLA、大小脑、世界模型与强化学习

具身智能是机器人实现感知-决策-执行闭环的核心范式,其本质在于物理世界中的具身化交互能力。技术演进围绕如何高效建模环境、理解指令并生成鲁棒动作展开,衍生出四大主流路径:视觉-语言-动作(VLA)端到端学习、大小脑分层控制、世界模型驱动预测,以及强化学习原生策略优化。VLA强调多模态对齐与泛化能力,适合语义理解优先场景;大小脑架构兼顾实时性与可解释性,是工业落地的高可靠选择;世界模型追求内在物理模拟,代表长期认知跃迁方向;强化学习则扎根仿真试错,在力控、抓取等连续控制任务中展现强鲁棒性。本文聚焦这四大路线的技

weixin_32181267的博客 300

GraphRAG深度解析:架构设计与实战案例

生成模块结合检索到的图数据和用户输入的查询,生成高质量的文本输出。通过结合图数据库中的知识,模型可以更准确地回答用户的问题,提供更优质的客户服务。通过分析用户的行为和偏好,结合图数据库中的知识,模型可以为用户提供个性化的推荐。:通过图数据库存储和检索结构化的知识,为语言模型提供丰富的背景信息,提升生成内容的质量和准确性。:选择合适的图数据库,如Neo4j、OrientDB等,以支持高效的图数据存储和检索。:利用图数据库的高效检索能力,快速找到与用户查询最相关的图元素,提高系统的响应速度。

加入“Super Entity”,与全能开发团队共探AI智能体与数字人项目,开启前沿技术之旅。 1595

Java字符串:hashCode() 方法

Java hashCode() 方法 hashCode() 方法用于返回字符串的哈希码。 字符串对象的哈希码根据以下公式计算: s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1] 使用 int 算法,这里 s[i] 是字符串的第 i 个字符,n 是字符串的长度,^ 表示求幂。空字符串的哈希值为 0。 语法 public int hashCode() ...

Mr_chen的博客 2940

metahuman 下载材质 脸部灰白 脸部过亮

metahuman 下载材质 脸部灰白 脸部过亮

jacke121的专栏 247

Java中equals()和HashCode()的关系

前言 上一篇文章简单分析了equals()与==的关系,本文我们再来看看equals()与hashcode()的关系。hashcode的使用还是有很多坑的,一起看看吧~ 本文主要有以下几点来分析: hashCode使用中产生的问题 equals/hashcode的渊源 产生问题的原因 正确的使用姿势 hashCode使用中产生的问题 注:HashSet是一个无序、不可重复的集合,我们做一个小测...

LarsCheng's Blog 1万+

怀旧版电脑GBC模拟器

再现原版GBC掌机的界面,电脑运行连游戏界面都一样大小,很怀旧,很真实,(英文版)强烈推荐,很小的文件,很难才找到的。

Data-Structures-and-Algorithm-Analysis-in-Java.pdf

作者: Weiss, Mark A. 出版社: Addison Wesley Data Structures and Algorithm Analysis in Java is an “advanced algorithms” book that fits between traditional CS2 and Algorithms Analysis courses. In the old ACM Curriculum Guidelines, this course was known as CS7. This text is for readers who want to learn good programming and algorithm analysis skills simultaneously so that they can develop such programs with the maximum amo...

java中hashcode和equals的区别和联系

理解: 规范1:若重写equals(Object obj)方法,有必要重写hashcode()方法,确保通过equals(Object obj)方法判断结果为true的两个对象具备相等的hashcode()返回值。说得简单点就是:“如果两个对象相同,那么他们的hashcode应该 相等”。不过请注意:这个只是规范,如果你非要写一个类让equals(Object obj)返回true而hashco...

qq_42273599的博客 7401

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

【Java】Object类中的equals()和hashCode()

= 是用来比较两个对象的引用(内存地址)是否相同,对于基本数据类型比较的是值。equals() 方法是用来比较两个对象的内容是否相equals()同,通常在类中会重写该方法来判断内容的相等。

m0_75260099的博客 1179

Camera2Demo

在Camera2 的基础上进行封装,使得Camera2一堆初始化逻辑与Activity分离,降低耦合度,完成预览拍照并保存的操作

Java中equals()、hashCode()与“==“的深度解析

在Java中,==、equals()和hashCode()各有其用途,理解它们的区别和正确实现方式是编写健壮代码的基础。==适用于引用比较,equals()用于内容比较,而hashCode()确保哈希集合的正确性。通过遵循Java的约定、避免常见陷阱并采用最佳实践,开发者可以确保对象比较的可靠性和性能。无论是处理字符串、自定义对象还是集合操作,正确使用这些方法将显著提升代码质量。

持续输出Java相关知识 1649

探索equals()和hashCode()方法

如果你现在还对hashcode了解甚少的话,建议你先看看下面两篇博客,绝对有用,面试中经常问这些。 《java中Map,List与Set的区别》 《05.Hash Tables(哈希表)》 equals()和hashCode()区别? ------------------------------------------------- equals():反映

8170

Java中==、equals() 的区别和 hashCode() 的关系

特性==equals()hashCode()用途比较基本类型值或对象引用比较对象内容生成对象的哈希码比较对象基本类型和引用类型只能是对象只能是对象默认行为比较值或引用比较引用(与==相同)基于对象地址可重写否是是与集合的关系无关用于contains()等操作用于哈希集合的存储和查找==比较值或引用,equals()比较内容,hashCode()生成哈希码重写equals()时必须重写hashCode()相等的对象必须有相同的哈希码。

Z123C456H的博客 1009

Java hashCode() 和 equals()的若干问题解答

hashCode() equals()

m0_60476942的博客 946

Java 中的 Object、equals() 和 hashCode() 深度剖析

=:比较的是基本数据类型的值或者引用数据类型的引用。equals():比较的是引用数据类型的内容(前提是该类重写了equals()方法)。通过本文的介绍,我们深入了解了 Java 中的Object类、equals()方法和hashCode()方法的核心知识点。Object类是所有类的父类,提供了基本的方法。equals()方法用于定义对象相等的逻辑,可以通过重写来自定义比较行为。hashCode()方法与equals()方法紧密相关,只有同时重写这两者,才能保证对象在哈希表等数据结构中的正确性。

2403_87729201的博客 1234

equals() 和 hashCode()

作为 Java 开发者,我们经常会用到equals()和hashCode()这两个方法。它们是Object类中定义的基础方法,看似简单,但如果理解不透彻,很容易在实际开发中踩坑。本文将深入探讨这两个方法的作用、区别、以及如何正确地重写它们。

liu174的博客 1515

一文搞定equals()和hashcode()的重写问题

一文搞定equals()和hashcode()的重写问题

weixin_55682785的博客 1422

java基础篇(22) equals()与hashCode()方法详解

概述 java.lang.Object类中有两个非常重要的方法: public boolean equals(Object obj) public int hashCode() Object类是类继承结构的基础,所以是每一个类的父类。所有的对象,包括数组,都实现了在Object类中定义的方法。 equals()方法详解 equals()方法是用来判断其他的对象是否和该对象相等. equals()...

cowbin2012的专栏 1万+

java重写equals()方法和hashCode()方法

引用块内容 1.equals()方法和hashCode()方法是什么? equals()和hashCode()都是是Java中万物之源Object类中的方法; equals方法用于比较两个对象是否相同,Object类中equals方法的实现是比较引用地址来判断的对象是否是同一个对象,通过覆盖该方法可以实现自定义的判断规则; hashCode是jdk根据对象的地址或者字符串或者数字计算...

潘超博客 2万+

Java中==、equals()和hashCode()的比较分析

在Java语言中,==、equals()、hashCode()这三个方法都和对象的比较有关,

liumei90 3740
上一篇: 关于Android中涉及屏幕适配的单位dp,px,sp,dip的学习笔记。
下一篇: Android学习笔记之资源文件resource/raw和assets各自的特点。
RockCode_li
博客等级 码龄12年 3粉丝 17原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值