자바 소스 분석 슈퍼 인터페이스 맵

머리말
우리 가 앞에서 말 한 것 은 링크 든 배열 이 든 모두 자신의 장단 점 이 있다.배열 의 조회 속도 가 빠 르 고 삽입 이 느 리 며 링크 는 삽입 할 때 우수 하지만 조회 가 무력 하 다.해시 표 는 배열 과 링크 의 장점 을 통합 시 켜 삽입 과 검색 등에 서 좋 은 속 도 를 낼 수 있다.우리 가 이후 분석 하고 자 하 는 HashMap 은 해시 표를 바탕 으로 이 루어 졌 으 나 JDK 1.8 에 붉 은 검 은 나무 도 도입 되 어 성능 이 한층 향상 되 었 다.
오늘 슈퍼 인터페이스 맵 에 대해 서 말씀 드 리 겠 습 니 다.
인터페이스 맵
Map 은 Key-Value 의 데이터 형식 을 기반 으로 하고 key 값 은 중복 되 지 않 으 며 각 key 에 대응 하 는 value 값 이 유일 합 니 다.Map 의 key 도 null 일 수 있 지만 중복 할 수 없습니다.
Map 인 터 페 이 스 를 보 는 방법 전에 Map.Entry 인 터 페 이 스 를 살 펴 보 자.
2.인터페이스 맵.Entry
keyset()방법 반환 값 은 Map 에서 key 값 의 집합 입 니 다.entry Set()의 반환 값 도 set 집합 을 되 돌려 줍 니 다.이 집합 유형 은 Map.Entry 입 니 다.
Map.Entry 는 Map 성명 의 내부 인터페이스 로 이 인 터 페 이 스 는 범 형 으로 Entry로 정의 합 니 다.이것 은 맵 의 실체(key-value 쌍)를 표시 합 니 다.인터페이스 에 getKey(),getValue 방법 이 있 습 니 다.

//      key
K getKey();

//      value
V getValue();

//      value
V setValue(V value);

//       equals hashCode
boolean equals(Object o);
int hashCode();

//  1.8 ,         ,        
public static <K extends Comparable<? super K>, V> Comparator<Map.Entry<K,V>> comparingByKey() {
        return (Comparator<Map.Entry<K, V>> & Serializable)
            (c1, c2) -> c1.getKey().compareTo(c2.getKey());
}
3.몇 가지 중요 한 방법

//         
int size();

//     
boolean isEmpty();

//       key,     key equals  ,  key     
boolean containsKey(Object key);

//      key     value,    equals  
boolean containsValue(Object value);

//   key     value 
V get(Object key);

//   key-value
V put(K key, V value);

//     key-value 
V remove(Object key);

//    Map  
void putAll(Map<? extends K, ? extends V> m);

//   
void clear();

//      key Set   ,  key     ,Set      
Set<K> keySet();

//      values
Collection<V> values();

//   key-value  Set 
Set<Map.Entry<K, V>> entrySet();

//       equals hashCode
boolean equals(Object o);
int hashCode();
4.슈퍼 실현 클래스 AbstractMap
AbstractCollection 에 대응 하여 AbstractMap 의 역할 도 비슷 합 니 다.주로 몇 가지 방법 을 제공 하여 실현 하 는 것 입 니 다.구체 적 인 실현 류 의 코드 량 을 줄 이 고 계승 하기에 편리 합 니 다.다음은 그것 이 어떤 방법 을 실 현 했 는 지 살 펴 보 자.
방법 을 보기 전에 정 의 된 두 변 수 를 살 펴 보 세 요.

transient Set<K>        keySet;
transient Collection<V> values;
방법:

//     ,      entrySet   
public int size() {
    return entrySet().size();
}

public boolean isEmpty() {
    return size() == 0;
}

//  entrySet  
public boolean containsKey(Object key) {
        Iterator<Map.Entry<K,V>> i = entrySet().iterator();
        if (key==null) {
            while (i.hasNext()) {
                Entry<K,V> e = i.next();
                if (e.getKey()==null)
                    return true;
            }
        } else {
            while (i.hasNext()) {
                Entry<K,V> e = i.next();
                if (key.equals(e.getKey()))
                    return true;
            }
        }
        return false;
    }

public boolean containsValue(Object value) {
    //...
}

public V get(Object key) {
    //...
}

public V remove(Object key) {
    //...
}

public void clear() {
    entrySet().clear();
}
그 밖 에 도 많은 기본 적 인 실현 방법 을 제공 하 였 으 니,우 리 는 그 중의 하 나 를 봅 시다.

public Set<K> keySet() {
    Set<K> ks = keySet;
    if (ks == null) {
        ks = new AbstractSet<K>() {
            public Iterator<K> iterator() {
                return new Iterator<K>() {
                    private Iterator<Entry<K,V>> i = entrySet().iterator();

                    public boolean hasNext() {
                        return i.hasNext();
                    }

                    public K next() {
                        return i.next().getKey();
                    }

                    public void remove() {
                        i.remove();
                    }
                };
            }

            public int size() {
                return AbstractMap.this.size();
           }

            public boolean isEmpty() {
               return AbstractMap.this.isEmpty();
            }

            public void clear() {
                AbstractMap.this.clear();
            }

            public boolean contains(Object k) {
                return AbstractMap.this.containsKey(k);
            }
        };
        keySet = ks;
    }
    return ks;
}
위의 방법 외 에 도 AbstractMap 은 equals,hashCode,toString,clone 등 방법 을 실현 하여 구체 적 으로 실현 할 때 많은 작업 을 절약 할 수 있 습 니 다.
자바 소스 코드 해석 의 슈퍼 인터페이스 맵 에 관 한 이 글 은 여기까지 소개 되 었 습 니 다.더 많은 자바 슈퍼 인터페이스 맵 내용 은 우리 의 이전 글 을 검색 하거나 아래 의 관련 글 을 계속 조회 하 시기 바 랍 니 다.앞으로 많은 응원 바 랍 니 다!

좋은 웹페이지 즐겨찾기