Estructura de Datos - Mapa de interfaz

breve introducción

Uno por lo general la mayoría de las estructuras de datos común, es la clave que constituye el, sistema de mapa interno no puede contener duplicados de las llaves, pero pueden contener valores duplicados.

mapa de interfaz

public interface Map<K,V>

Mapa método no está implementado

// 获取元素个数
int size();
// 是否为空
boolean isEmpty();
// 是否包含key
boolean containsKey(Object key);
// 是否包含value
boolean containsValue(Object value);
// 根据key取值
V get(Object key);
// 添加元素
V put(K key, V value);
// 移除key
V remove(Object key);
// 添加一个Map集合
void putAll(Map<? extends K, ? extends V> m);
// 清除
void clear();
// 获取整个key集合
Set<K> keySet();
// 获取所有值
Collection<V> values();
// 获取所有键值对
Set<Map.Entry<K, V>> entrySet();
// 比较是否一样
boolean equals(Object o);
// 获取集合hashCode
int hashCode();

Mapear el método por defecto

default V getOrDefault(Object key, V defaultValue) {
    V v;
    // key不存在或key对应值为空返回默认值，否有返回实际值
    return (((v = get(key)) != null) || containsKey(key))
            ? v
            : defaultValue;
}

La clave de registro de valores, el valor predeterminado se devuelve vacío o ausente

default V putIfAbsent(K key, V value) {
    V v = get(key);
    // key为空则添加
    if (v == null) {
        v = put(key, value);
    }
    return v;
}

Si la clave no existe o está vacía luego añadir esta pares de valores clave

default boolean remove(Object key, Object value) {
    Object curValue = get(key);
    // value不一样或key不存在返回false
    if (!Objects.equals(curValue, value) ||
            (curValue == null && !containsKey(key))) {
        return false;
    }
    remove(key);
    return true;
}

Si el valor de la clave correspondiente al mismo valor para borrar

default boolean replace(K key, V oldValue, V newValue) {
    Object curValue = get(key);
    // 旧值与key对应值不同时返回false
    if (!Objects.equals(curValue, oldValue) ||
            (curValue == null && !containsKey(key))) {
        return false;
    }
    put(key, newValue);
    return true;
}

Reemplazar el valor antiguo con el nuevo valor, y el valor antiguo no devuelve un valor que corresponde a la tecla al mismo tiempo falsa

default V replace(K key, V value) {
    V curValue;
    if (((curValue = get(key)) != null) || containsKey(key)) {
        curValue = put(key, value);
    }
    return curValue;
}

Cuando la llave está presente, un valor que cubra el valor original, devuelve un vacío no existe

Mapa de interfaz de entrada de clases interna

interface Entry<K,V>

Mapa Entrada método de clase interna

K getKey();
V getValue();
V setValue(V value);
boolean equals(Object o);
int hashCode();

Define el comportamiento básico de pares de valores clave

AbstractMap clase abstracta

public abstract class AbstractMap<K,V> implements Map<K,V>

Teniendo en cuenta todo el esqueleto colección básica Mapa

propiedad AbstractMap

// 键集合
transient Set<K>        keySet;
// 值集合
transient Collection<V> values;

AbstractMap Constructor

AbstractMap protegido () {
}

AbstractMap método no se implementa

public abstract Set<Entry<K,V>> entrySet();

implementos AbstractMap un método que no sea el entrySet () que no sea la interfaz del mapa.

El método ha sido aplicado AbstractMap

En han puesto en práctica estos métodos, sólo es necesario iguales de enfoque y métodos hashcode pueden ser, otros métodos han sido cubiertos por la subclase

public boolean equals(Object o) {
    // 地址一样时为true
    if (o == this)
        return true;
    // 不是Map或子类实例时为false
    if (!(o instanceof Map))
        return false;
    // 强转o为Map
    Map<?,?> m = (Map<?,?>) o;
    // m长度为空
    if (m.size() != size())
        return false;
    try {
        // 遍历当前集合所有元素
        Iterator<Entry<K,V>> i = entrySet().iterator();
        while (i.hasNext()) {
            Entry<K,V> e = i.next();
            K key = e.getKey();
            V value = e.getValue();
            // 有任意一个值不像等就返回false
            if (value == null) {
                if (!(m.get(key)==null && m.containsKey(key)))
                    return false;
            } else {
                if (!value.equals(m.get(key)))
                    return false;
            }
        }
    } catch (ClassCastException unused) {
        return false;
    } catch (NullPointerException unused) {
        return false;
    }
    // 循环完返回true
    return true;
}

Analizar es igual manera, para determinar el tipo, se determina la longitud, después de la determinación de elementos, que es diferente de la Lista, Lista de elementos de la secuencia conducirá a diferentes iguales diferentes, aquí comprenden el uso de un modo de comparación y el valor. El primer elemento está vacío, otros elementos pueden sin límite de orden.

public int hashCode() {
    int h = 0;
    // 遍历所有元素
    Iterator<Entry<K,V>> i = entrySet().iterator();
    while (i.hasNext())
        // 元素hashCode累加
        h += i.next().hashCode();
    return h;
}

Método código hash es sumar todos los elementos de código hash