现实生活中，我们常会看到这样的一种集合：IP地址与主机名，身份证号与个人，系统用户名与系统用户对象等，这种一一对应的关系，就叫做映射。Java提供了专门的集合类用来存放这种对象关系的对象，即java.util.Map接口。
我们通过查看Map接口描述，发现Map接口下的集合与Collection接口下的集合，它们存储数据的形式不同，如下图。
Collection中的集合，元素是孤立存在的（理解为单身），向集合中存储元素采用一个个元素的方式存储。Map中的集合，元素是成对存在的(理解为夫妻)。每个元素由键与值两部分组成，通过键可以找对所对应的值。Collection中的集合称为单列集合，Map中的集合称为双列集合。Map中的集合不能包含重复的键(key)，值(value)可以重复；每个键只能对应一个值。通过查看Map接口描述，看到Map有多个子类，这里我们主要讲解常用的HashMap集合、LinkedHashMap集合。
tips：Map接口中的集合都有两个泛型变量<K,V>,在使用时，要为两个泛型变量赋予数据类型。两个泛型变量<K,V>的数据类型可以相同，也可以不同。
Map接口中定义了很多方法，常用的如下：
public V put(K key, V value): 把指定的键与指定的值添加到Map集合中。public V remove(Object key): 把指定的键所对应的键值对元素在Map集合中删除，返回被删除元素的值。public V get(Object key) 根据指定的键，在Map集合中获取对应的值。boolean containsKey(Object key) 判断集合中是否包含指定的键。public Set<K> keySet(): 获取Map集合中所有的键，存储到Set集合中。public Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的键值对对象的集合(Set集合)。Map接口的方法演示
public class MapDemo {
public static void main(String[] args) {
//创建 map对象
HashMap<String, String> map = new HashMap<String, String>();
//添加元素到集合
map.put("黄晓明", "杨颖");
map.put("文章", "马伊琍");
map.put("邓超", "孙俪");
System.out.println(map);
//String remove(String key)
System.out.println(map.remove("邓超"));
System.out.println(map);
// 想要查看 黄晓明的媳妇 是谁
System.out.println(map.get("黄晓明"));
System.out.println(map.get("邓超"));
}
}
MAP集合的特点
package Demo01; import java.util.HashMap; import java.util.Map; /** * @author 270 * java.util.Map<k,v>集合 * 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>接口 * 1.HashMap集合底层是哈希表，查询速度特别的快 * 2.hashMap集合是一个无序的集合，存储的元素和取出元素的顺序可能会变 * java.util.linkedHashMap<k,v>集合，extends HashMap<k,v>集合 * 1.LinkedHashMap集合底层是哈希表+链表 * 2.LinkedHashMap集合是一个有序的集合，存储元素和取出元素的顺序是一致的 * * 常用方法： * public V put(K key, V value): 把指定的键与指定的值添加到Map集合中。 * 返回值 V * 存储键值对的时候，key不重复，返回值v是null * 存储键值对的时候，key重复，会使用新的value替换Map中重复的value，返回【被替换的value值】 * public V remove(Object key):把指定的键所对应的键值对元素 在Map集合中删除，返回被删除元素的值。 * 返回值 V * 存储键值对的时候，key不重复，返回值v是null * 存储键值对的时候，key重复，会使用新的value替换map中重复的value，返回【被替换的alue值】 * public V get(Object key)根据指定的键，在Map集合中获取对应的值。 * 返回值 V * key存在，返回对应的value值 * key不存在，返回null * boolean containsKey(Object key) 判断集合中是否包含指定的键。 * public Set<K> keySet(): 获取Map集合中所有的键，存储到Set集合中。 * public Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的键值对对象的集合(Set集合)。 */ public class Demo01Map { public static void main(String[] args) { show01(); System.out.println("============================="); show02(); } private static void show02() { Map<String,Integer> map = new HashMap<>(); map.put("厄斐琉斯",168); map.put("迷失之牙",165); map.put("发条魔灵",159); System.out.println(map); Integer i1 = map.remove("迷失之牙"); Integer i2 = map.remove("迷失之"); System.out.println(i2); System.out.println(map); Integer integer1 = map.get("厄斐琉斯"); System.out.println("integer1:"+integer1); Integer integer2 = map.get("桂鬼"); System.out.println("integer2:"+integer2); System.out.println(map.containsKey("厄斐琉斯")); System.out.println(map.containsKey("gui")); } private static void show01() { Map<String,String> map = new HashMap<>(); String v1 = map.put("桂", "高杉1"); System.out.println("v1:"+v1); String v2 = map.put("桂", "高杉2"); System.out.println("v2:"+v2); System.out.println(map); map.put("狗子","猫猫"); map.put("鬼鬼","猫猫"); map.put("赵粤","张艺兴"); System.out.println(map); } } 输出结果: v1:null v2:高杉1 {桂=高杉2} {桂=高杉2, 鬼鬼=猫猫, 狗子=猫猫, 赵粤=张艺兴} ============================= {厄斐琉斯=168, 发条魔灵=159, 迷失之牙=165} null {厄斐琉斯=168, 发条魔灵=159} integer1:168 integer2:null true falsetips:
使用put方法时，若指定的键(key)在集合中没有，则没有这个键对应的值，返回null，并把指定的键值添加到集合中；
若指定的键(key)在集合中存在，则返回值为集合中键对应的值（该值为替换前的值），并把指定键所对应的值，替换成指定的新值。
键找值方式：即通过元素中的键，获取键所对应的值
分析步骤：
keyset()get(K key)代码演示：
package Demo01;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
/**
* @author 270
* Map集合的第一种遍历方式：通过键找值的方式
* Map集合中的方法：
* Set<K>keyset() 返回此映射中包含的键的 Set 视图
* 实现步骤：
* 1.使用Map集合中的方法keyset（），
* 把Map集合中所有的key取出来，存储到一个set当中
* 2.遍历set集合，获取Map集合中的每一个key
* 3.通过Map集合中的方法get（key），通过key找到value
*/
public class Demo02KeySet {
public static void main(String[] args) {
Map<String,Integer> map = new HashMap<>();
map.put("厄斐琉斯",168);
map.put("迷失之牙",165);
map.put("发条魔灵",159);
//1.使用Map集合中的方法keySet（），把Map集合中所有的key取出来
Set<String> set = map.keySet();
//2.遍历set集合，获取Map集合中的每一个key
//使用迭代器或者增强for循环
Iterator<String> iterator = set.iterator();
while (iterator.hasNext()){
String key = iterator.next();
//通过key找到value
Integer value = map.get(key);
System.out.println(key+"="+value);
}
System.out.println("===============");
for (String key:set
) {
Integer value = map.get(key);
System.out.println(key+"="+value);
}
}
}
public class MapDemo01 {
public static void main(String[] args) {
//创建Map集合对象
HashMap<String, String> map = new HashMap<String,String>();
//添加元素到集合
map.put("胡歌", "霍建华");
map.put("郭德纲", "于谦");
map.put("薛之谦", "大张伟");
//获取所有的键 获取键集
Set<String> keys = map.keySet();
// 遍历键集 得到 每一个键
for (String key : keys) {
//key 就是键
//获取对应值
String value = map.get(key);
System.out.println(key+"的CP是："+value);
}
}
}
我们已经知道，Map中存放的是两种对象，一种称为key(键)，一种称为value(值)，它们在在Map中是一一对应关系，这一对对象又称做Map中的一个Entry(项)。Entry将键值对的对应关系封装成了对象。即键值对对象，这样我们在遍历Map集合时，就可以从每一个键值对（Entry）对象中获取对应的键与对应的值。
既然Entry表示了一对键和值，那么也同样提供了获取对应键和对应值得方法：
public K getKey()：获取Entry对象中的键。public V getValue()：获取Entry对象中的值。在Map集合中也提供了获取所有Entry对象的方法：
public Set<Map.Entry<K,V>> entrySet()`: 获取到Map集合中所有的键值对对象的集合(Set集合)。
package Demo01;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
/**
* @author 270
* Map遍历集合的第二种方式，使用Entry对象遍历
*
* Map集合中的方法：
* Set<Map.Entry<K,V>> entrySet()
*
* 实现步骤：
* 1.使用Map集合中的方法entrySet(),把Map集合中多个Entry对象取出来，
* 存储到一个set集合中。
* 2.遍历Set集合，获取每一个Entry对象
* 3.使用Entry对象中的方法getKey()和getValue获取键与值
*
*/
public class Demo03EntrySet {
public static void main(String[] args) {
Map<String,Integer> map = new HashMap<>();
map.put("厄斐琉斯",168);
map.put("迷失之牙",165);
map.put("发条魔灵",159);
Set<Map.Entry<String, Integer>> set = map.entrySet();
Iterator<Map.Entry<String, Integer>> it = set.iterator();
while (it.hasNext()){
Map.Entry<String, Integer> entry = it.next();
String key = entry.getKey();
Integer value = entry.getValue();
System.out.println(key+"="+value);
}
System.out.println("=====================");
for (Map.Entry<String,Integer> entry:set){
Integer value = entry.getValue();
String key = entry.getKey();
System.out.println(key+"="+value);
}
}
}
键值对方式：即通过集合中每个键值对(Entry)对象，获取键值对(Entry)对象中的键与值。
操作步骤与图解：
获取Map集合中，所有的键值对(Entry)对象，以Set集合形式返回。方法提示:entrySet()。
遍历包含键值对(Entry)对象的Set集合，得到每一个键值对(Entry)对象。
通过键值对(Entry)对象，获取Entry对象中的键与值。 方法提示:getkey() getValue()
public class MapDemo02 {
public static void main(String[] args) {
// 创建Map集合对象
HashMap<String, String> map = new HashMap<String,String>();
// 添加元素到集合
map.put("胡歌", "霍建华");
map.put("郭德纲", "于谦");
map.put("薛之谦", "大张伟");
// 获取 所有的 entry对象 entrySet
Set<Entry<String,String>> entrySet = map.entrySet();
// 遍历得到每一个entry对象
for (Entry<String, String> entry : entrySet) {
// 解析
String key = entry.getKey();
String value = entry.getValue();
System.out.println(key+"的CP是:"+value);
}
}
}
tips：Map集合不能直接使用迭代器或者foreach进行遍历。但是转成Set之后就可以使用了。
练习：每位学生（姓名，年龄）都有自己的家庭住址。那么，既然有对应关系，则将学生对象和家庭住址存储到map集合中。学生作为键, 家庭住址作为值。
注意，学生姓名相同并且年龄相同视为同一名学生。
编写学生类：
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public boolean equals(Object o) {
if (this == o)
return true;
if (o == null || getClass() != o.getClass())
return false;
Student student = (Student) o;
return age == student.age && Objects.equals(name, student.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
//也可以在这里重写toString方法，这样在主方法打印key的时候会直接显示Student对象的属性值
}
编写测试类：
public class HashMapTest {
public static void main(String[] args) {
//1,创建Hashmap集合对象。
Map<Student,String>map = new HashMap<Student,String>();
//2,添加元素。
map.put(newStudent("lisi",28), "上海");
map.put(newStudent("wangwu",22), "北京");
map.put(newStudent("zhaoliu",24), "成都");
map.put(newStudent("zhouqi",25), "广州");
map.put(newStudent("wangwu",22), "南京");
//3,取出元素。键找值方式
Set<Student> keySet = map.keySet();
for(Student key: keySet){
Stringvalue = map.get(key);
System.out.println(key.toString()+"....."+value);
}
}
}
java.util.LinkedHashMap集合来存放。我们知道HashMap保证成对元素唯一，并且查询速度很快，可是成对元素存放进去是没有顺序的，那么我们要保证有序，还要速度快怎么办呢？
在HashMap下面有一个子类LinkedHashMap，它是链表和哈希表组合的一个数据存储结构。
public class LinkedHashMapDemo {
public static void main(String[] args) {
LinkedHashMap<String, String> map = new LinkedHashMap<String, String>();
map.put("邓超", "孙俪");
map.put("李晨", "范冰冰");
map.put("刘德华", "朱丽倩");
Set<Entry<String, String>> entrySet = map.entrySet();
for (Entry<String, String> entry : entrySet) {
System.out.println(entry.getKey() + " " + entry.getValue());
}
}
}
结果:
邓超 孙俪
李晨 范冰冰
刘德华 朱丽倩
package Demo01;
import java.util.HashMap;
/**
* @author 270
* java.util.HashTable<K,V> implements Map<K,V>接口
*
* Hashtable：底层也是一个哈希表，是一个线程安全的集合，是单线程集合
* HashMap：底层是一个哈希表，是一个线程不安全的集合，是多线程的集合
*
* HashMap集合：（之前学的所有集合）：可以存储null值，null键
* Hashtable集合：不能存储null值和null键
*
* Hashtable和Vector集合一样，在jdk1.2版本之后被更先进的集合（HashMap，ArrayList）取代了
* Hashtable的子类properties依然活跃在历史舞台
* properties集合是唯一一个和IO流相结合的集合
*/
需求：
计算一个字符串中每个字符出现次数。
分析：
代码：
public class MapTest {
public static void main(String[] args) {
//友情提示
System.out.println("请录入一个字符串:");
String line = new Scanner(System.in).nextLine();
// 定义 每个字符出现次数的方法
findChar(line);
}
private static void findChar(String line) {
//1:创建一个集合存储字符以及其出现的次数
HashMap<Character, Integer> map = new HashMap<Character, Integer>();
//2:遍历字符串
for (int i = 0; i < line.length(); i++) {
char c = line.charAt(i);
//判断 该字符 是否在键集中
if (!map.containsKey(c)) {//说明这个字符没有出现过
//那就是第一次
map.put(c, 1);
} else {
//先获取之前的次数
Integer count = map.get(c);
//count++;
//再次存入 更新
map.put(c, ++count);
}
}
System.out.println(map);
}
}
通常，我们在代码中创建一个集合（例如，List 或 Set ），并直接用一些元素填充它。 实例化集合，几个 add方法 调用，使得代码重复。
public class Demo01 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("abc");
list.add("def");
list.add("ghi");
System.out.println(list);
}
}
Java 9，添加了几种集合工厂方法,更方便创建少量元素的集合、map实例。新的List、Set、Map的静态工厂方法可以更方便地创建集合的不可变实例。
例子：
public class HelloJDK9 {
public static void main(String[] args) {
Set<String> str1=Set.of("a","b","c");
//str1.add("c");这里编译的时候不会错，但是执行的时候会报错，因为是不可变的集合
System.out.println(str1);
Map<String,Integer> str2=Map.of("a",1,"b",2);
System.out.println(str2);
List<String> str3=List.of("a","b");
System.out.println(str3);
}
}
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* @author 270
* JDK：Set接口，Map接口：里面创建了静态方法of，可以给集合一次性添加多个元素
* Set<String> List<E> of(E....elements)
* 使用前提：
* 当集合中存储的元素个数已经确定了，不再改变时使用
* 注意：
* 1.of方法只适用于List接口，Set接口，不适用于接口的实现类
* 2.of方法的【返回值是一个不能改变的集合】，集合不能再使用add，put方法添加元素，否则会抛出异常。
* 3.Set接口和Map接口在调用of方法时，不能有【重复】的元素，否则会抛出异常。
*
*
*/
public class Demo01 {
public static void main(String[] args) {
List<String> list = List.of("a", "b", "c", "d");
System.out.println(list);
Set<String> strings = Set.of("a", "v","a");
//java.lang.IllegalArgumentException:
Map<String, Integer> map = Map.of("厄斐琉斯", 18, "迷失之牙", 22);
System.out.println(map);
}
}
需要注意以下两点：
1**:of()方法只是Map，List，Set这三个接口的静态方法，其父类接口和子类实现并没有这类方法，比如 HashSet，ArrayList等待；**
2:返回的集合是不可变的；
使用IDEA的断点调试功能，查看程序的运行过程
在有效代码行，点击行号右边的空白区域，设置断点，程序执行到断点将停止，我们可以手动来运行程序
点击Debug运行模式
程序停止在断点上不再执行，而IDEA最下方打开了Debug调试窗口
Debug调试窗口介绍
快捷键F8，代码向下执行一行,第九行执行完毕，执行到第10行（第10行还未执行）
切换到控制台面板，控制台显示 请录入一个字符串： 并且等待键盘录入
快捷键F8，程序继续向后执行，执行键盘录入操作，在控制台录入数据 ababcea
此时到达findChar方法，快捷键F7，进入方法findChar
快捷键F8 接续执行，创建了map对象，变量区域显示
快捷键F8 接续执行，进入到循环中，循环变量i为 0,F8再继续执行，就获取到变量c赋值为字符‘a’ 字节值97
快捷键F8 接续执行，进入到判断语句中，因为该字符 不在Map集合键集中，再按F8执行，进入该判断中
快捷键F8 接续执行，循环结束，进入下次循环，此时map中已经添加一对儿元素
快捷键F8 接续执行，进入下次循环，再继续上面的操作，我们就可以看到代码每次是如何执行的了
如果不想继续debug,那么可以使用快捷键F9,程序正常执行到结束，程序结果在控制台显示
按照斗地主的规则，完成洗牌发牌的动作。
具体规则：
规则：手中扑克牌从大到小的摆放顺序：大王,小王,2,A,K,Q,J,10,9,8,7,6,5,4,3
完成数字与纸牌的映射关系：
使用双列Map(HashMap)集合，完成一个数字与字符串纸牌的对应关系(相当于一个字典)。
通过数字完成洗牌发牌
将每个人以及底牌设计为ArrayList,将最后3张牌直接存放于底牌，剩余牌通过对3取模依次发牌。
存放的过程中要求数字大小与斗地主规则的大小对应。
将代表不同纸牌的数字分配给不同的玩家与底牌。
通过Map集合找到对应字符展示。
通过查询纸牌与数字的对应关系，由数字转成纸牌字符串再进行展示。
import java.util.*;
/**
* @author 270
*/
public class Test {
public static void main(String[] args) {
//用HashMap创建牌盒
HashMap<Integer, String> pokers = new HashMap<>();
//创建索引
ArrayList<Integer> pokerIndex = new ArrayList<>();
//添加数字集合和花色集合
List<String> colors = List.of("?", "?", "?", "?");
List<String> numbers = List.of("2", "A", "K", "Q", "J", "10", "9", "8", "7", "6", "5", "4", "3");
//大小王存入集合
int index = 0;
pokers.put(index, "大王");
pokerIndex.add(index);
index++;
pokers.put(index, "小王");
pokerIndex.add(index);
index++;
//将其他花色和数字组合存入HashMap中
//这里要先遍历数字再遍历花色，这样才能使不同花色相同数字的牌索引相连，不会出现不同花色数字索引有差别的情况
for (String s1 : numbers
) {
for (String s2 : colors
) {
pokers.put(index, s1 + s2);
pokerIndex.add(index++);
}
}
//洗牌
Collections.shuffle(pokerIndex);
//创建四个集合存储三个玩家和底牌
ArrayList<Integer> p1 = new ArrayList<>();
ArrayList<Integer> p2 = new ArrayList<>();
ArrayList<Integer> p3 = new ArrayList<>();
ArrayList<Integer> underCard = new ArrayList<>();
//发牌
for (int i = 0; i < pokerIndex.size(); i++) {
Integer in = pokerIndex.get(i);
if (i > 51) {
underCard.add(i);
}
if (i % 3 == 0) {
p1.add(in);
} else if (i % 3 == 1) {
p2.add(in);
} else if (i % 3 == 2) {
p3.add(in);
}
}
//排序
//Collections.sort(List)
Collections.sort(p1);
Collections.sort(p2);
Collections.sort(p3);
Collections.sort(underCard);
//通过索引将牌面找到
ArrayList<String> pl1 = new ArrayList<>();
ArrayList<String> pl2 = new ArrayList<>();
ArrayList<String> pl3 = new ArrayList<>();
ArrayList<String> dp = new ArrayList<>();
for (Integer i : p1
) {
pl1.add(pokers.get(i));
}
for (Integer i : p2
) {
pl2.add(pokers.get(i));
}
for (Integer i : p3
) {
pl3.add(pokers.get(i));
}
for (Integer i : underCard
) {
dp.add(pokers.get(i));
}
//输出
System.out.println(pl1);
System.out.println(pl2);
System.out.println(pl3);
System.out.println(dp);
}
}