本帖最后由 小石姐姐 于 2018-11-22 09:23 编辑
Map体系Map集合概述
java.util.Map<K, V>接口Map集合特点: 1. 是双列集合, 一个元素包含两个值 (键key, 值value)
2. key和value的类型可以相同, 也可以不同
3. key不允许重复, value可以重复
4. key和value是一一对应的, 一个键只能对应一个值
//Map集合适合存储一对一关系的数据Map常用子类java.util.Map<K, V>接口: 双列集合的根接口, 规定了共性的方法 | |_ HashMap<K, V>类: 底层哈希表. key存取无序不可重复 |_ LinkedHashMap类: 底层哈希表+链表. key存取有序不可重复 映射: 键和值的对应关系 mapping HashSet底层使用的就是HashMapLinkedHashSet底层使用的就是LinkedHashMap Map中常用方法Map<String, Phone> map = new HashMap<>();
map.put("张三", p1);
map.put("张三", p2);
java.util.Map接口: 双列集合的顶层
// 成员方法
V put(K key, V value): 添加/修改键值对. 如果键存在, 则用新值替换已有值
V remove(Object key): 根据键删除键值对, 返回被删除元素的值
V get(Object key): 根据键获取值. 如果键不存在, 则返回null
boolean containsKey(Object key): 判断是否包含指定的键
Set<K> keySet(): 获取Map集合中所有的键, 存储到Set集合中
Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的Entry对象的集合(Set集合)
补充：
entry 节点
Map key value public class Entry {
+---------------+ K key;
V value;
| K key, V value| V getValue();
K getKey();
+---------------+
// JDK 9对于集合初始化的优化
java.util.List
// 静态方法
static List<E> of(E... e): 返回包含指定元素的 不可变List 集合
java.util.Set
// 静态方法
static Set<E> of(E... e): 返回包含指定元素的 不可变Set 集合
java.util.Map
// 静态方法
static Map<K, V> of(K k1, V v1): 返回包含指定键值对的 不可变Map 集合
Map遍历方式一: keySet()方法实现通过键找值Set<K> keySet(): 获取Map集合中所有的键, 存储到Set集合中 keySet()遍历步骤:
1. Map对象调用 keySet() 方法, 获取包含所有key的Set集合
2. 遍历Set集合, 获取每个key
3. 通过Map对象调用 get(Object key) 方法根据key获取到value
4. 
[Java] 纯文本查看 复制代码 public static void main(String[] args) {
Map<String, String> map = new HashMap<>(); //创建Map集合
map.put(); //为集合添加元素
Set<String> key = map.keySet(); // 获取每个元素的键值 存到一个set集合中
for (String keys : key) { //遍历循环 set集合
value=map.get(keys); //通过map集合中的方法get(key).通过key找到vlaue
System.out.println(keys+"="+value);
}
}
[Java] 纯文本查看 复制代码 Map<String, Integer> map = new HashMap<>();
map.put("赵丽颖", 168);
map.put("杨颖", 165);
map.put("林志玲", 178);
Set<String> key = map.keySet(); //集合
for (String keys : key) { //keys 元素
Integer value = map.get(keys); //通过键获取值
System.out.println(keys+"="+value);
}
System.out.println("--------------------");
Iterator<String> iterator = map.keySet().iterator();
while (iterator.hasNext()){
String keyss = iterator.next();
Integer value = map.get(keyss);
System.out.println(keyss+"="+value);
}
System.out.println("---------------------");
for (String key1 : map.keySet()) {
Integer value = map.get(key1);
System.out.println(key1+"="+value);
}
Entry键值对对象介绍java.util.Map.Entry接口: // 常用成员方法 K getKey(): 获取Entry对象中的键 V getValue(): 获取Entry对象中的值! Entry对象就是一个节点, 节点中存储了key和value拿到一个Entry对象就可以从中获取key和value
[Java] 纯文本查看 复制代码 Map<String, String> map = new HashMap<>();
// keySet()遍历
Set<Map.Entry<String, String>> entries = map.entrySet();
for (Map.Entry<String, String> entry : entries) {
// 通过Entry对象获取每个键值对
String value = entry.getKey();
String value = entry.getValue();
// 打印当前键值对
System.out.println(key + "=" + value);
}
/*创建HashMap集合, 存储以下键值对
"赵丽颖", 168
"杨颖", 165
"林志玲", 178
使用entrySet()方式遍历Map, 打印键值对*/
public static void main(String[] args) {
Map<String, String> map = new HashMap<>();
map.put("赵丽颖", "赵颖");
map.put("杨颖", "赵颖");
map.put("林志玲", "赵颖");
Set<Map.Entry<String, String>> set = map.entrySet(); //普通增强for循环
for (Map.Entry<String, String> key : set) {
String key1 = key.getKey();
String value = key.getValue();
System.out.println(key1+"="+value);
}
System.out.println("-------------------------");
Iterator<Map.Entry<String, String>> iterator = map.entrySet().iterator();
while (iterator.hasNext()){ //迭代器循环
Map.Entry<String, String> keys = iterator.next();
String K = keys.getKey();
String value = keys.getValue();
System.out.println(K+"="+value);
}
System.out.println("-------------------------");
for (Map.Entry<String, String> stringStringEntry : map.entrySet()) {
String KK = stringStringEntry.getKey();
String VV = stringStringEntry.getValue(); //简单增强for循环
System.out.println(KK+"="+VV);
}
java.util.Map接口 Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的键值对对象的集合(Set集合) Map遍历方式2: 通过entrySet()获取Entry对象形式遍历java.util.Map接口 Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的键值对对象的集合(Set集合) entrySet()方法遍历Map步骤: 1. Map对象调用 entrySet() 获取包含所有Entry对象的Set集合 2. 遍历Set集合, 获取每个Entry对象 3. 调用Entry对象的 getKey() 和 getValue() 方法获取键和值 HashMap存储自定义数据类型作为键HashMap存储自定义JavaBean对象作为key保证key唯一不重复, 需要让JavaBean重写 hashCode() 和 equals() 方法
定义Person类:
私有成员变量: 姓名String name, 年龄int age
生成无参/有参构造, set/get方法, toString, hashCode(), equals()
定义测试类:
创建4个Person对象, 分别如下:
"女王", 18
"秦始皇", 18
"普京", 30
"女王", 18
创建HashMap集合, 存入键为4个Person对象, 值为对应国家字符串: 英国, 秦国, 俄罗斯, 毛里求斯
使用entrySet()方法遍历Map集合, 输出键值对
[Java] 纯文本查看 复制代码 public static void main(String[] args) {
HashMap<Person, String> map = new HashMap<>();
Person p1=new Person("女王",18);
Person p2=new Person("秦始皇",18);
Person p3=new Person("普京",18);
Person p4=new Person("女王",18);
map.put(p1,"英国");
map.put(p2,"秦国");
map.put(p3,"俄罗斯");
map.put(p4,"毛里求斯");
for (Map.Entry<Person, String> personStringEntry : map.entrySet()) {
Person key = personStringEntry.getKey();
String value = personStringEntry.getValue();
System.out.println(key+"--->"+value);
}
System.out.println("------------------");
for (Person person : map.keySet()) {
String values = map.get(person);
System.out.println(person+"--->"+values);
}
}
//keySet(); person+map.get(person)
//entrySet(); 元素.getkey(); 元素.getvalue();LinkedHashMap类LinkedHashMap底层: 哈希表 + 链表 key不允许重复, 但key存取有序LinkedHashSet的底层就是使用LinkedHashMap实现的 JDK9对集合添加的优化使用集合添加大量元素时, 反复add(...)比较麻烦. JDK 9 为集合提供了一些静态方法, 可以方便的对集合进行初始化
java.util.List
// 静态方法
static List<E> of(E... e): 返回包含指定元素的 不可变List 集合
java.util.Set
// 静态方法
static Set<E> of(E... e): 返回包含指定元素的 不可变Set 集合
java.util.Map
// 静态方法
static Map<K, V> of(K k1, V v1, ...): 返回包含指定键值对的 不可变Map 集合
注意:
1. of() 方法只适用于List接口, Set接口, Map接口, 不适用于接接口的实现类
2. of() 方法的返回值是一个不能改变的集合, 集合不能再使用 add(), put() 方法添加元素, 会抛出异常
3. Set接口和Map接口在调用 of() 方法的时候, 不能有重复的元素, 否则会抛出异常
/*
需求:
使用List.of()方法, 添加1,2,3, 获取集合对象, 使用增强for遍历打印输出
使用Set.of()方法, 添加1,2,3, 获取集合对象, 使用增强for遍历打印输出
使用Map.of()方法, 添加"a":1, "b":2, "c":3, 获取集合对象, 使用entrySet()遍历打印输出
*/
[Java] 纯文本查看 复制代码 public class Test {
public static void main(String[] args) {
// List<Integer> list = List.of(1, 2, 3);
// List<Integer> list = List.of(1, 2, 3); // int[] arr = {1,2,3,4}
// ArrayList<Integer> arrayList = new ArrayList(list);
ArrayList<Integer> arrayList = new ArrayList(List.of(1, 2, 3));
arrayList.add(10);
arrayList.add(20);
for (Integer integer : arrayList) {
System.out.println(integer);
}
// Set<Integer> set = Set.of(1, 2, 3);
HashSet<Integer> set = new HashSet<>(Set.of(1, 2, 3));
set.add(10);
for (Integer integer : set) {
System.out.println(integer);
}
// Map<String, Integer> map = Map.of("a", 1, "b", 2, "c", 3);
Map<String, Integer> map = new HashMap<>(Map.of("a", 1, "b", 2, "c", 3));
map.put("z", 123);
for (Map.Entry<String, Integer> entry : map.entrySet()) {
String key = entry.getKey();
Integer value = entry.getValue();
System.out.println(key + "=" + value);
}
}
}
Debug调试模式介绍断点: breakpoint, 在debug模式下, 程序运行到断点会暂停住, 便于我们在程序运行过程中查看Debug调试程序: 可以让代码逐行执行,查看代码执行的过程,调试程序中出现的bug使用方式: 在行号的右边,鼠标左键单击,添加断点(每个方法的第一行,哪里有bug添加到哪里) 右键,选择Debug执行程序 程序就会停留在添加的第一个断点处执行程序: f8:逐行执行程序 f7:进入到方法中 shift+f8:跳出方法 f9:跳到下一个断点,如果没有下一个断点,那么就结束程序 ctrl+f2:退出debug模式,停止程序 Console:切换到控制台 斗地主发牌案例**有(大小)序斗地主: 需求分析**需求: 实现斗地主发牌, 特殊要求是看牌时按照从小到大顺序排列
分析:
准备牌:
为了牌有大小顺序, 给牌编号, 一个编号对应一张牌: 0=大王, 1=小王, 2=♤2, 3=♤3
编号和牌是一对一映射关系, 用HashMap<Integer, String>存储, key为编号, value为牌
再为编号单独创建一个额外的ArrayList<Integer> pokerIndex
定义编号变量 int index = 0;
按照编号添加大小王
嵌套for循环拼接序号和花色, 存入HashMap, 同时将编号存入ArrayList, 编号index++
洗牌:
Collections.shuffle(List list)将编号的ArrayList pokerIndex打乱顺序
发牌:
创建4个ArrayList, 前3个是玩家, 最后一个是底牌
遍历编号的ArrayList pokerIndex, 发编号给玩家, >=51时发给底牌
对4个ArrayList排序
看牌
定义方法: public static void lookPoker(String name,HashMap<Integer,String> poker,ArrayList<Integer> list)
打印姓名, 遍历编号集合ArrayList<Integer> list获取每个编号, 通过编号从HashMap<Integer,String> poker中获取牌, 打印
调用方法
[Java] 纯文本查看 复制代码 public static void main(String[] args) {
List<String> colors = List.of("♠", "♥", "♣", "♦");
List<String> numbers = List.of("2", "A", "K", "Q", "J", "10", "9", "8", "7", "6", "5", "4", "3");
//创建map集合装字符
Map<Integer, String> poker = new HashMap<>();
//创建list集合装index
ArrayList<Integer> pokerIndex = new ArrayList<>();
int index=0;
poker.put(index,"大王");
pokerIndex.add(index);
index++;
poker.put(index," 小王");
pokerIndex.add(index);
index++;
for (String color : colors) {
for (String number : numbers) {
poker.put(index,color+number);
pokerIndex.add(index);
index++;
}
}
Collections.shuffle(pokerIndex);
ArrayList<Integer> diPai = new ArrayList<>();
ArrayList<Integer> Player1 = new ArrayList<>();
ArrayList<Integer> Player2 = new ArrayList<>();
ArrayList<Integer> Player3 = new ArrayList<>();
for (int i = 0; i < pokerIndex.size(); i++) {
if (i>=51){
diPai.add(pokerIndex.get(i));
}else if(i%3==0){
Player1.add(pokerIndex.get(i));
}else if (i%3==1){
Player2.add(pokerIndex.get(i));
}else if (i%3==2){
Player3.add(pokerIndex.get(i));
}
}
Collections.sort(Player1);
Collections.sort(Player2);
Collections.sort(Player3);
lookPlayer("张飞",poker,Player1);
lookPlayer("张飞",poker,Player2);
lookPlayer("张飞",poker,Player3);
lookPlayer("底牌",poker,diPai);
}
public static void lookPlayer( String name,Map<Integer,String> poker,ArrayList<Integer> list){
System.out.print(name+" ");
for (Integer integer : list) {
String pai = poker.get(integer);
System.out.print(pai+" ");
}
System.out.println();
}
|
收藏
淘帖
踩
