HashMap 의 key 에서 자바 의 '=' 과 'equals' 의 차이 점 을 볼 수 있 습 니 다.

자바 에서 두 변수 가 같은 지 아 닌 지 를 어떻게 판단 하 느 냐 가 중요 하 다.일반적으로 주소 가 같 으 면 내용 은 틀림없이 같 을 것 이 고, 그렇지 않 으 면 그렇지 않다.따라서 같은 지 여 부 를 판단 할 때 우 리 는 주소 가 같은 지 내용 이 같은 지 구분 해 야 한다.
그래서 두 가지 판단 방법 을 설명 합 니 다.
"= =" 값 비교: 변수 (스 택 메모리) 에 저 장 된 대상 의 메모리 주소
"equals" 는 두 대상 의 내용 을 비교 합 니 다. (스 택 메모리 에 저 장 된 내용 은 주소 가 아 닙 니 다)
기본 / 인용 유형 에 대한 차이 점:

기본 유형: = equals 와 두 값 이 같 는 지 비교 합 니 다.true 와 같 습 니 다. 그렇지 않 으 면 false 입 니 다.

참조 형식: = equals 검색 과 스 택 메모리 의 주소 가 같 는 지 비교 합 니 다.true 와 같 습 니 다. 그렇지 않 으 면 false 입 니 다.

String 형식의 특수성
문자열 변수 에 있어 서 '= =' 과 '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，   。
s3==s4 //true：s3 s4              ，"        "    ,    s3=s4    

HashMap 에서 같은 key 의 판단
결론: - String 타 입 을 제외 하고 equals (내용 에 따라 같은 key 찾기) 와 hashCode (내용 에 따라 같은 통 찾기) 를 다시 씁 니 다. -만약 두 대상 이 같다 면 (즉, equals 로 true 로 되 돌아 가 는 것) 그들의 hashCode 값 은 반드시 같 아야 합 니 다. -두 대상 의 hashCode 가 같다 면 반드시 같 지 않 습 니 다 (즉, equals 로 false 를 비교 합 니 다).원본 코드 는 다음 과 같 습 니 다.

//  key hashCode  hash ，    idexFor   i  
    int hash = hash(key.hashCode());
    int i = indexFor(hash, table.length); 
//      key       e=e.next，  ==||equals     key  
if (e.hash == hash && ((k = e.key) == key || key.equals(k))
//    ：
public int hashCode() {  
        int result = 17;  
        result = result * 31 + name.hashCode();  
        result = result * 31 + age;  

        return result;  
    }  
public boolean equals(Object other) { 
 if(other == this)  
            return true;  
if(!(other instanceof Coder))  
            return false;  
Coder o = (Coder)other;  
        return o.name.equals(name) && o.age == age; 
      } 

메모: - Object 클래스 의 equals 방법 은 "= =" 과 같 습 니 다. 차이 가 없습니다. String 류, Integer 류 등 일부 종 류 는 equals 방법 을 다시 써 서 equals 와 "= = 다 릅 니 다"."= =" 은 "equal" 보다 운행 속도 가 빠 릅 니 다. 왜냐하면 "=" 은 비교적 참조 일 뿐 입 니 다.

 //            ,     "","",  ==      , equals     .
    public boolean isAnagram(String s, String t) {
        char[] s1 = s.toCharArray();
        char[] s2 = t.toCharArray();
        Arrays.sort(s1);
        Arrays.sort(s2);
        //   s1   s2          ，      ，==   。
        if(new String(s1).equals(new String(s2)))
            return true;
        else return false;
    }
    public static void main(String[] args){
        String s1="";
        String s2="";
        GroupAnagrams g = new GroupAnagrams();
        System.out.print(g.isAnagram(s1,s2));
    }

부록 1: HashMap 소스 코드 put 실현

// hash key   ，    Entry value       value。    hash    key    ，             。
public V put(K key, V value) {
        // key null，  putForNullKey  ，  null table      ，  HashMap   null   
        if (key == null)
            return putForNullKey(value);
        //  key hash 
        int hash = hash(key.hashCode());                  ------(1)
        //  key hash    table       
        int i = indexFor(hash, table.length);             ------(2)
        // i      e,   key      
        for (Entry e = table[i]; e != null; e = e.next) {
            Object k;
            //         hash    (key  )
            //     ，     value，   value
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;    //   =   
                e.value = value;
                e.recordAccess(this);
                return oldValue;     //    
            }
        }
        //      1
        modCount++;
        // key、value   i   
        addEntry(hash, key, value, i);
        return null;
    }

참고 자료
HashMap 원리