Java学习----Map接口
今日学习内容总结如下：
Map接口
哈希表就是一种以键-值(key-indexed) 存储数据的结构，只要输入待查找的值即key，即可查找到其对应的值。
哈希的思路很简单，如果所有的键hashCode都是整数，那么就可以使用一个简单的无序数组来实现：将键作为索引，值即为其对应的值，这样就可以快速访问任意键的值。
它提供了一组键值的映射。其中存储的每个数据对象都有一个相应的键key，键决定了值对象在Map中的存储位置。键应该是唯一的，不允许重复，每个key只能映射一个value。
Map接口的定义
public interface Map<K, V> 表示存储数据时有2个部分key和value，key不允许重复
int size(); 获取key-value个数
boolean containsKey(Object key);判断集合中是否包含指定的key值
要求key类型需要实现equals和hashCode发方法
首先调用hashCode方法获取key对应的hash值，然后当key值和map中的key值相同时才会继续调用equals进行等值判断，否则是false
boolean containsValue(Object value);判断集合中是否包含指定的value值
要求value类型需要实现equals，对于hashCode没有要求；进行判断时是直接调用equals方法
V get(Object key);根据key值获取对应的value值
如果key不存在，则返回为null；即使key值不存在也不会抛异常
获取数据返回为null有2种情形：没有对应的key，存储key对应的值为null
V put(K key, V value);向map集合中添加key-value对，返回原始存储的value值
如果key值已经存在则后盖前，同时返回被覆盖的数据
要求针对key类型必须实现equals和hashCode两个方法
Java的潜规则：要求当两个对象的equals为true时，hashCode值必须相等
@Override
public int hashCode() {
return Objects.hash(id, name);
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
A3 other = (A3) obj;
return Objects.equals(id, other.id) && Objects.equals(name, other.name);
}V remove(Object key); 根据key值删除对应的key-value对，返回对应的value值
如果key值不存在，不会抛出异常，只是返回值为null；如果key值存在则返回对应的value
获取数据返回为null有2种情形：没有对应的key，存储key对应的值为null
void clear();清空集合中的所有元素key-value对
遍历map集合有三种方式，map提供了三种不同的视图
1、Iterator 2、.forEach(lambda) 3、for-each结构 for(Object tmp: map.keySet)
Set<K> keySet();获取所有的key所组成的Set集合
Collection<V> values();获取所有的value所组成的Collection集合
Set<Map.Entry<K, V>> entrySet();获取所有的key-value对所构成的Set集合
在Map中一个key-value被封装成一个Entry的对象
interface Entry<K, V> {
K getKey(); 当前entry对象中存储的key值
V getValue(); 当前entry对象中存储的value值
V setValue(V value); 修改entry对象中所存储的value值
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());
}
public static <K, V extends Comparable<? super V>> Comparator<Map.Entry<K, V>> comparingByValue() {
return (Comparator<Map.Entry<K, V>> & Serializable)
(c1, c2) -> c1.getValue().compareTo(c2.getValue());
}
public static <K, V> Comparator<Map.Entry<K, V>> comparingByKey(Comparator<? super K> cmp) {
Objects.requireNonNull(cmp);
return (Comparator<Map.Entry<K, V>> & Serializable)
(c1, c2) -> cmp.compare(c1.getKey(), c2.getKey());
}
public static <K, V> Comparator<Map.Entry<K, V>> comparingByValue(Comparator<? super V> cmp) {
Objects.requireNonNull(cmp);
return (Comparator<Map.Entry<K, V>> & Serializable)
(c1, c2) -> cmp.compare(c1.getValue(), c2.getValue());
}
}新增方法:
按照key值获取key所对应的value值，如果key值不存在则返回defaultValue；
如果key存在，即使值为null，也是返回value值，不是defaultValue
default V getOrDefault(Object key, V defaultValue) {
V v;
return (((v = get(key)) != null) || containsKey(key))
? v
: defaultValue;
}遍历当前Map集合中的所有元素
default void forEach(BiConsumer<? super K, ? super V> action) {
Objects.requireNonNull(action); //判断非action非空，如果action为null则抛出异常
for (Map.Entry<K, V> entry : entrySet()) { for-each结构
K k;
V v;
try {
k = entry.getKey();
v = entry.getValue();
} catch (IllegalStateException ise) {
throw new ConcurrentModificationException(ise);
}
action.accept(k, v);
}
} 对应的lambda表达式接口定义为
@FunctionalInterface
public interface BiConsumer<T, U> {
void accept(T t, U u);
}可以使用lambda表达式修改Map中所有的value值
default void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
Objects.requireNonNull(function); 要求function参数非空，否则异常
for (Map.Entry<K, V> entry : entrySet()) {for-each结构用于遍历所有的key-value对
K k;
V v;
try {
k = entry.getKey(); 获取当前entry对象中的key值
v = entry.getValue(); 获取当前entry对象中的value值
} catch (IllegalStateException ise) {
throw new ConcurrentModificationException(ise);
}
v = function.apply(k, v);调用BiFunction中的方法对key和value进行处理，并返回一个V类型的数据
try {
entry.setValue(v);将计算得到的新数据注入到entry对象中，实现数据的修改
} catch (IllegalStateException ise) {
throw new ConcurrentModificationException(ise);
}
}
}
@FunctionalInterface
public interface BiFunction<T, U, R> {
R apply(T t, U u); //针对传入的t和u进行处理，可以返回一个新的类型数据
}按照key值修改原始数据，如果key对应的值为空，则修改数据为value，否则返回旧有数据，不修改
default V putIfAbsent(K key, V value) {
V v = get(key); //首先按照key获取对应的value值
if (v == null) { //如果获取的value为空，则修改key对应的值为参数value
v = put(key, value);
}
return v; //返回v值，如果v非空则返回原始数据，如果v为空则返回value
}
按照key和value值执行删除操作
default boolean remove(Object key, Object value) {
Object curValue = get(key); //获取key对应的原始数据
//如果原始存储的数据和value参数不相等或者不存在对应的key并且key对应存储的原始数据为null，//则不执行任何操作
if (!Objects.equals(curValue, value) ||
(curValue == null && !containsKey(key))) {
return false;
}
remove(key); //删除key对应的数据
return true;
}按照指定的key和oldValue值执行替换操作，将key对应的值修改为newValue
default boolean replace(K key, V oldValue, V newValue) {
Object curValue = get(key); //按照key获取对应的当前存储的value值
//如果当前存储的值和oldValue参数值不相等或者当前值为null并且不包含当前的key，则直接返回
if (!Objects.equals(curValue, oldValue) ||
(curValue == null && !containsKey(key))) {
return false;
}
put(key, newValue); //修改key所对应的value为newValue
return true;
}
按照指定的key进行修改，要求key对应的value非空或者包含对应的key
default V replace(K key, V value) {
V curValue;
if (((curValue = get(key)) != null) || containsKey(key)) {
curValue = put(key, value);
}
return curValue;
}