Map集合
Map集合
Map集合的特点：
1、Map集合是一个双列集合，一个元素包含两个值（一个key，一个value）
2、Map集合中的元素，key和value的数据类型可以相同，也可以不同
3、Map集合中的元素，key是不允许重复的，value是可以重复的
4、Map集合中的元素，key和value是一一对应
java.util.HashMap<k,v>集合 implements Map<k,v>接口
HashMap集合的特点：
1、HashMap集合底层是哈希表：查询的速度特别快
JDK1.8之前：数组+单向链表
JDK1.8之后：数组+单向链表/红黑树（链表的长度超过8）：提高查询的速度
2、HashMap集合是一个无序的集合，存储元素和取出元素的顺序有可能不一致
java.util.linkedHashMap<k,v>集合 extends HashMap<k,v>集合
2、LinkedHashMap集合是一个有序的集合，存储元素和取出元素的顺序一致的
LinkedHashMap的特点：
- LinkedHashMap集合底层是哈希表+链表（保证迭代的顺序）
- LinkedHashMap集合是一个有序的集合，存储元素和取出元素的顺序是一致的
Map接口的常用方法
public V put(K key,V value):把指定的键与指定的值添加到Map集合中
返回值：V 存储键值对的时候，key不重复，返回值v是null；key重复，会使用新的value替换map中原来的value，返回值为原来的value。
public class Demo01Map {
public static void main(String[] args) {
show1();
}
private static void show1() {
Map<String, String> map = new HashMap<>();
String v1 = map.put("李晨", "范冰冰1");
System.out.println(v1);//null
String v2 = map.put("李晨", "范冰冰2");
System.out.println(v2);//范冰冰1
System.out.println(v2);
map.put("冷风", "飒飒");
map.put("惊雷", "轰隆");
map.put("暴雨", "哒哒");
map.put("暴雨", "呲呲");
System.out.println(map);//{惊雷=轰隆, 李晨=范冰冰2, 暴雨=呲呲, 冷风=飒飒}
}
}
public V remove(Object key):把指定的键所指定的键值对元素在Map集合中删除，返回被删除元素的value。
返回值：V key存在，V为被删除的值，不存在，返回null。
public class Demo01Map {
public static void main(String[] args) {
show2();
}
private static void show2() {
Map<String, Integer> map = new HashMap<>();
map.put("杨幂", 26);
map.put("刘亦菲", 18);
map.put("林志玲", 35);
map.put("张磊", 30);
System.out.println(map);//{张磊=30, 林志玲=35, 杨幂=26, 刘亦菲=18}
Integer v1 = map.remove("林志玲");
System.out.println(v1);//35
System.out.println(map);//{张磊=30, 杨幂=26, 刘亦菲=18}
Integer v2 = map.remove("林志颖");
System.out.println(v2);//null
}
}
public V get(Object key):根据指定的键，在Map结合中获取对应的值。
返回值：V key存在返回对应的value值，不存在，返回null。
System.out.println(map.get("林志玲"));//null
System.out.println(map.get("刘亦菲"));//18
boolean containsKey(Object key):判断集合中是否包含指定的键。包含返回true，不包含，返回flash。
System.out.println(map.containsKey("林志玲"));//false
System.out.println(map.containsKey("刘亦菲"));//true
Map集合遍历键找值1
Map集合的第一种遍历方式：通过键找值的方式。
Map集合中的方法：Set
实现步骤：
- 使用Map集合中的方法keySet(),把Map集合所有的key取出来，存储到一个Set集合中
- 遍历set集合，获取Map集合中的每一个key
- 通过Map集合中的方法get(key),通过key找到value
public class KeySet {
public static void main(String[] args) {
//创建Map集合对象
Map<String, Integer> map = new HashMap<>();
map.put("杨幂", 26);
map.put("刘亦菲", 18);
map.put("林志玲", 35);
map.put("张磊", 30);
//1.使用Map集合中的方法keySet(),把Map集合所有的key取出来，存储到一个Set集合中
Set<String> set = map.keySet();
//2.遍历set集合，获取Map集合中的每一个key
//使用迭代器遍历Set集合
Iterator<String> it = set.iterator();
while (it.hasNext()){
String key=it.next();
//3.通过Map集合中的方法get(key),通过key找到value
Integer value = map.get(key);
System.out.println(key+"="+value);
}
System.out.println("====================");
for (String key:map.keySet()
) {
Integer value = map.get(key);
System.out.println(key+"="+value);
}
}
}
Entry键值对
Map.Entry<K,V>:在Map接口中有一个内部接口Entry。
作用：当Map集合已创建，那么就会在Map集合中创建一个Entry对象，用来记录键与值(键与值的映射关系)。
Set<Map.Entry<K,V>> entrySet():把Map集合内部的多个Entry对象取出来存储到一个Set集合
Map集合遍历键值对方式2
使用Entry对象遍历：
Map集合中的方法：Set<Map.Entry<K,V>> entrySet() 返回此映射中包含的键的Set视图
实现步骤
1.使用Map集合中的方法entrySet(),把Map集合中多个Entry对象取出来，存储到一个Set集合中
2.遍历Set集合，获取每一个Entry对象
3.使用Entry对象中的方法getKey()和getValue()获取键与值
public static void main(String[] args) {
Map<String,Integer> map=new HashMap<>();
map.put("杨幂", 26);
map.put("刘亦菲", 18);
map.put("林志玲", 35);
map.put("张磊", 30);
System.out.println(map);
System.out.println("===============");
//1.使用Map集合中的方法entrySet(),把Map集合中多个Entry对象取出来，存储到一个Set集合中
Set<Map.Entry<String, Integer>> set = map.entrySet();
//2.遍历Set集合，获取每一个Entry对象
//使用增强for循环
for (Map.Entry<String, Integer> entry:set) {
//3.使用Entry对象中的方法getKey()和getValue()获取键与值*/
System.out.println(entry.getKey()+"="+(entry.getValue()));
}
System.out.println("===============");
//使用迭代器
Iterator<Map.Entry<String, Integer>> it = set.iterator();
while (it.hasNext()){
Map.Entry<String, Integer> next = it.next();
//3.使用Entry对象中的方法getKey()和getValue()获取键与值*/
System.out.println(next.getKey()+"="+(next.getValue()));
}
}
}
HashMap存储自定义类型键值
Map集合保证key值是唯一的。
作为key的元素，必须重写hashCode方法和equals方法，以保证key唯一。
public class Demo01HashMapSavePerson {
public static void main(String[] args) {
show01();
show02();
}
/*
HashMap存储自定义类型键值
key:Person类型
Person类就必须重写hashCode方法和equals方法，以保证key唯一
value:String类型
可以重复
*/
private static void show02() {
//创建HashMap集合
HashMap<Person, String> map = new HashMap<>();
//往集合中添加元素
map.put(new Person("女王", 18), "英国");
map.put(new Person("秦始皇", 68), "秦国");
map.put(new Person("普京", 18), "俄罗斯");
map.put(new Person("女王", 18), "毛里求斯");
//使用entrySet和增强for遍历Map集合
Set<Map.Entry<Person, String>> set = map.entrySet();
for (Map.Entry<Person, String> entry : set) {
//创建同类型变量进行接收
Person key = entry.getKey();
String value = entry.getValue();
System.out.println(key + "-->" + value);
}
}
//-------------------------------------------------
/*
HashMap存储自定义类型键值
key:String 类型
String类重写hashCode方法和equals方法，可以保证key唯一
value:Person类型
value可以重复(同名同年龄的人视为同一个)
*/
private static void show01() {
//创建HashMap集合
HashMap<String, Person> map = new HashMap<>();
//往集合中添加元素
map.put("北京", new Person("张三", 18));
map.put("上海", new Person("李四", 19));
map.put("广州", new Person("王五", 20));
map.put("北京", new Person("赵六", 17));
//使用keySet 和增强for 遍历Map集合
Set<String> set = map.keySet();
for (String key : set) {
Person value = map.get(key);
//因为map集合不允许存储重复的key，所以赵六把张三替换了
System.out.println(key + " -->" + value);
}
}
}
LinkedHashMap集合
java.util.LinkedHashMap<K,V> extends HashMap<K,V> 。Map接口的哈希表和链接列表实现，具有可预知的迭代顺序。
底层原理：哈希表+链表(记录元素顺序)
public class DemoLinkedHashMap {
public static void main(String[] args) {
HashMap<String, String> map = new HashMap<>();
map.put("a","a");
map.put("i","i");
map.put("e","e");
map.put("o","o");
map.put("a","u");
System.out.println(map);//{a=u, e=e, i=i, o=o},无序，会按默认规则升序,不允许重复
HashMap<String, String> linked = new LinkedHashMap<>();
linked.put("a","a");
linked.put("i","i");
linked.put("e","e");
linked.put("o","o");
linked.put("a","u");
System.out.println(linked);//{a=u, i=i, e=e, o=o}有序，不允许重复
}
}
添加多个元素
List接口，Map接口，Map接口：里面增加了一个静态的方法of，可以给集合一次性添加多个元素。
static
使用前提：当集合中粗糙农户的元素的个数已经确定了。不再改变是使用。
注意：
- of方法只适用于List接口，Set接口，Map接口，不适应于接口的实现类。
- of方法的返回值是一个不能改变的集合，集合不能在使用add，put方法添加元素，会抛出异常。
- Set接口和Map接口在调用方法的时候，不能有重复的元素，否则会抛出异常。
import java.util.List;
import java.util.Map;
import java.util.Set;
public class JDK {
public static void main(String[] args) {
List<String> list=List.of("a","b","c","a","d");
System.out.println(list);//[a, b, c, a, d]
//list.add("w");//UnsupportedOperationException:不支持操作异常
//Set<String> set=Set.of("a","b","c","a","d");
//IllegalArgumentException非法参数异常，有重复元素
Set<String> set=Set.of("a","b","c","d");
System.out.println(set);//[c, b, a, d]
Map<String, Integer> map = Map.of("张三", 15, "李四", 18, "王五", 35);
System.out.println(map);//{张三=15, 李四=18, 王五=35}
}
}
斗地主练习：
public class testPuke {
public static void main(String[] args) {
List<String> color = List.of("♠", "❤", "♣", "♦");//4
List<String> numbers = List.of("2", "A", "K", "Q", "J", "10", "9", "8", "7", "6", "5", "4", "3");//13
String[] p = new String[52];
int k = 0;
//拼接牌
for (int i = 0; i < color.size(); i++) {
for (int j = 0; j < numbers.size(); j++) {
p[k] = color.get(i) + numbers.get(j);
//System.out.print(p[k]+" ");
k++;
}
}
//System.out.println("=========================");
//System.out.println(p[13]);
//索引牌
List<Integer> pokerIndex = new ArrayList<>();
HashMap<Integer, String> map = new HashMap<>();
for (int i = 0; i < p.length; i++) {
map.put(i, p[i]);
pokerIndex.add(i);
}
map.put(52, " 🤡");
map.put(53, " 👹");
pokerIndex.add(52);
pokerIndex.add(53);
//洗牌
Collections.shuffle(pokerIndex);
ArrayList<Integer> palyer1 = new ArrayList<>();
ArrayList<Integer> palyer2 = new ArrayList<>();
ArrayList<Integer> palyer3 = new ArrayList<>();
ArrayList<Integer> palyer4 = new ArrayList<>();
//发牌
for (int i = 0; i < pokerIndex.size(); i++) {
Integer in = pokerIndex.get(i);
if (i > 50) {
palyer4.add(in);
} else if (i % 3 == 0) palyer1.add(in);
else if (i % 3 == 1) palyer2.add(in);
else if (i % 3 == 2) palyer3.add(in);
}
//排序
Collections.sort(palyer1);
Collections.sort(palyer2);
Collections.sort(palyer3);
Collections.sort(palyer4);
show(map,palyer1);
show(map,palyer2);
show(map,palyer3);
show(map,palyer4);
}
public static void show(HashMap<Integer,String> map,ArrayList<Integer> list){
for (int p1:list
) {
System.out.print(map.get(p1)+" ");
}
System.out.println("=================");
}
}
浙公网安备 33010602011771号