哈希表
哈希表就是一种以键-值(key-indexed) 存储数据的结构，只要输入待查找的值即key，即可查找到其对应的值。
哈希的思路很简单，如果所有的键hashCode都是整数，那么就可以使用一个简单的无序数组来实现：将键作为索引，值即为其对应的值，这样就可以快速访问任意键的值。
它提供了一组键值的映射。其中存储的每个数据对象都有一个相应的键key，键决定了值对象在Map中的存储位置。键应该是唯一的，不允许重复，每个key只能映射一个value。
Map接口的定义
public interface Map<K, V>
表示存储数据时有两个部分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集合
1、Iterator
2、.forEach(lambda)
3、for-each结构 for(Object tmp: map.keySet)
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
public class TestMap5 {
public static void main(String[] args) {
Map<Integer, String> map=new HashMap<>();
for(int i=0;i<5;i++)
map.put(i, "name-"+i);
//遍历所有的key值 Iterator forEach for-each
System.out.println("Integer for-each");
for(Integer key:map.keySet()) {
String value=map.get(key);
System.out.println(key+"---->"+value);
}
System.out.println();
//遍历所有的key值 Iterator forEach for-each
Collection<String> values=map.values();
System.out.println("Iterator");
Iterator<String> it=values.iterator();
while(it.hasNext()) {
String value=it.next();
//没有办法通过value获取对应的key，因为value允许重复
System.out.println(value);
}
System.out.println();
//遍历所有的Entry对象，Entry对象存储的是一个key-value对
Set<Entry<Integer, String>> entries=map.entrySet();
System.out.println("Entry<Integer, String> for-each");
for(Entry<Integer, String> en:entries) {
Integer key=en.getKey();
String value=en.getValue();
System.out.println(key+"--->"+value);
}
System.out.println();
//目前一般推荐使用lambda表达式
System.out.println("forEach");
map.entrySet().forEach(System.out::println);
System.out.println();
System.out.println("Lambda forEach value");
map.values().forEach((obj)->{
System.out.println(obj);
});
System.out.println();
System.out.println("Lambda forEach");
map.entrySet().forEach((obj)->{
Integer key=obj.getKey();
String value=obj.getValue();
System.out.println(key+"-->:"+value);
});
}
}
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());
}
@SuppressWarnings("unchecked")
public static <K, V> Map.Entry<K, V> copyOf(Map.Entry<? extends K, ? extends V> e) {
Objects.requireNonNull(e);
if (e instanceof KeyValueHolder) {
return (Map.Entry<K, V>) e;
} else {
return Map.entry(e.getKey(), e.getValue());
}
}
新增方法
按照key值获取key所对应的value值，如果key值不存在则返回defaultValue；
如果key存在，即使值为null，也是返回value值，不是defaultValuedefault 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);
}
}
}对应的lambda表达式
@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;
}
扫一扫
3485
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
