1.学生管理系统(课下完成)

1.1修改

 //修改private static void updateStudent(ArrayList<Student> list) {//创建键盘录入的对象Scanner sc = new Scanner(System.in);System.out.println("请输入要修改的学员的编号：");//获取录入的学员编号int input_id = sc.nextInt();//遍历list集合for (int i = 0; i < list.size(); i++) {//取出每个学生Student s = list.get(i);//获取学生编号int list_id = s.getId();//判断录入的编号和集合中取出的学生编号是否相等if(input_id == list_id){//说明找到了//录入学员新的信息并修改System.out.println("请输入新的学员姓名：(保留原值请输入0)");String name = sc.next();System.out.println("请输入新的学员性别：(保留原值请输入0)");String sex = sc.next();System.out.println("请输入新的学员生日：(保留原值请输入0)");String birthday = sc.next();//上述如果在控制台输入0属于字符串 "0"//判断是否修改姓名if(!"0".equals(name)){//说明希望修改s.setName(name);}//判断是否修改性别if(!"0".equals(sex)){//说明希望修改s.setSex(sex);}//判断是否修改生日if(!"0".equals(birthday)){//说明希望修改//修改生日s.setBirthday(birthday);//将新的生日传入到工具类中计算新的年龄int age = Utils.birthdayToAge(birthday);//新的年龄s.setAge(age);}System.out.println("【修改成功】");//停止方法 updateStudentreturn;}}//如果能够执行到这里，说明没有执行上述for循环中的if语句，因为if语句如果执行完毕最后有一个return直接结束方法了//也就是说没有找到和录入的学号相等的学号System.out.println("【你输入的编号不存在】");}

1.2删除

 //删除学生private static void deleteStudent(ArrayList<Student> list) {//创建键盘录入的对象Scanner sc = new Scanner(System.in);System.out.println("请输入要删除的学员的编号：");//录入的学员编号int input_id = sc.nextInt();/*这里不会报并发修改异常，因为只有使用迭代器Iterator或者增强for循环的时候才会报并发修改异常并发修改异常位于内部类Itr类中这里和迭代器没有关系，所以不会报并发修改异常*///遍历集合for (int i = 0; i < list.size(); i++) {//取出学生对象Student s = list.get(i);//获取集合中的学生编号int list_id = s.getId();//判断键盘录入的学生编号和集合中的学生编号是否一致if(input_id == list_id){//说明找到了学生，直接从集合中删除list.remove(i);//根据索引删除System.out.println("【删除成功】");//结束方法return;}}//如果能够执行到这里说明没有找到学员System.out.println("【您输入的编号有误】");}

2.Map集合介绍(掌握)

1.Map<K,V> 属于双列集合，每次可以添加一对数据，并且这两个数据具有映射关系。

举例：人和身份证 、身份证和驾驶证、老公和老婆等。都可以使用双列集合Map存储。

2.双列集合Map的第一个泛型：K是key的简写 表示键 ，V 是value的简写表示值，整体称为键值对

3.单列集合和双列集合区别

3.Map的继承体系（理解）

• HashMap<K,V>：存储数据采用的哈希表结构，元素的存取顺序不能保证一致。由于要保证键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。哈希表控制键，键唯一。
• LinkedHashMap<K,V>：HashMap下有个子类LinkedHashMap，存储数据采用的哈希表结构+链表结构。通过链表结构可以保证元素的存取顺序一致；通过哈希表结构可以保证的键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。
• TreeMap<K,V>：TreeMap集合和Map相比没有特有的功能，底层的数据结构是红黑树；可以对元素的**键进行排序，排序方式有两种:自然排序和比较器排序
• Hashtable被HashMap集合取代了 安全的，但是效率比HashMap低
• ConcurrentHashMap属于多线程安全，效率低 比Hashtable效率高

tips：Map接口中的集合都有两个泛型变量<K,V>,在使用时，要为两个泛型变量赋予数据类型。两个泛型变量<K,V>的数据类型可以相同，也可以不同。

4.Map接口的方法介绍(掌握)

package com.itheima.sh.map_method_01;import java.util.HashMap;
import java.util.Map;
import java.util.Set;/*Map接口中定义了很多方法，常用的如下：1.public V put(K key, V value)`:  把指定的键与指定的值添加到Map集合中。说明：1）执行put添加数据的时候，如果新添加的键不存在，那么此时直接添加，并返回null2）执行put添加数据的时候，如果新添加的键存在，那么新添加的value覆盖之前旧的value，并返回旧的value2.public V remove(Object key)`: 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值。3.public V get(Object key)` 根据指定的键，在Map集合中获取对应的值。4.public Set<K> keySet()`: 获取Map集合中所有的键，存储到Set集合中。5.public Set<Map.Entry<K,V>> entrySet()`: 获取到Map集合中所有的键值对对象的集合(Set集合)。说明：该方法表示获取Map集合中的所有的键值对，存放到单列集合Set中，键值对属于Map.Entry<K,V>类型6.public boolean containKey(Object key)`:判断该集合中是否有此键。 如果包含返回true，否则返回false7. int size() 返回此映射中的键-值映射关系数。 集合长度*/
public class MapDemo01 {public static void main(String[] args) {method_2();}private static void method_2() {Map<String, String> map = new HashMap<>();//添加数据map.put("黄晓明", "baby");map.put("谢霆锋", "王菲");map.put("汪峰", "章子怡");map.put("邓超", "孙俪");map.put("柳岩", "baby");// 2.public V remove(Object key)`: 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值。
//        String value = map.remove("柳岩");
//        System.out.println("value = " + value);
//        System.out.println("map = " + map);//map = {邓超=孙俪, 谢霆锋=王菲, 汪峰=章子怡, 黄晓明=baby}
//
//
//        //3.public V get(Object key)` 根据指定的键，在Map集合中获取对应的值。
//        //需求：根据谢霆锋获取值value
//        String value2 = map.get("谢霆锋");
//        System.out.println("value2 = " + value2);//王菲//4.public Set<K> keySet()`: 获取Map集合中所有的键，存储到Set集合中。Set<String> keys = map.keySet();System.out.println("keys = " + keys);//5.public Set<Map.Entry<K,V>> entrySet()`: 获取到Map集合中所有的键值对对象的集合(Set集合)。Set<Map.Entry<String, String>> entries = map.entrySet();//entries = [邓超=孙俪, 谢霆锋=王菲, 柳岩=baby, 汪峰=章子怡, 黄晓明=baby]System.out.println("entries = " + entries);//6.public boolean containKey(Object key)`:判断该集合中是否有此键。 如果包含返回true，否则返回false//需求判断是否包含 汪峰boolean boo = map.containsKey("汪峰");System.out.println("boo = " + boo);//boo = true//7. int size() 返回此映射中的键-值映射关系数。 集合长度System.out.println(map.size());// void putAll(Map<? extends K,? extends V> m) 将参数的map集合放到调用的map集合中//创建空的map集合Map<String, String> map2 = new HashMap<>();//将map集合的数据放到map2map2.putAll(map);//map2 = {邓超=孙俪, 柳岩=baby, 汪峰=章子怡, 谢霆锋=王菲, 黄晓明=baby}System.out.println("map2 = " + map2);}private static void method_1() {//使用子类创建对象//HashMap()构造一个具有默认初始容量 (16) 和默认加载因子 (0.75) 的空 HashMap。Map<String, String> map = new HashMap<>();//键和值的泛型类型可以不一致//添加数据//1）执行put添加数据的时候，如果新添加的键不存在，那么此时直接添加，并返回nullString s = map.put("黄晓明", "baby");System.out.println("s = " + s);//s = nullSystem.out.println(map);//{黄晓明=baby}//对于键黄晓明已经存在了，此时put方法就是将新的值杨幂覆盖之前旧的值baby 返回旧值baby给s1//2）执行put添加数据的时候，如果新添加的键存在，那么新添加的value覆盖之前旧的value，并返回旧的valueString s1 = map.put("黄晓明", "杨幂");System.out.println("s1 = " + s1);//s1 = babySystem.out.println(map);//{黄晓明=杨幂}}
}

小结：

 1.public V put(K key, V value)`:  把指定的键与指定的值添加到Map集合中。说明：1）执行put添加数据的时候，如果新添加的键不存在，那么此时直接添加，并返回null2）执行put添加数据的时候，如果新添加的键存在，那么新添加的value覆盖之前旧的value，并返回旧的value2.public V remove(Object key)`: 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值。3.public V get(Object key)` 根据指定的键，在Map集合中获取对应的值。4.public Set<K> keySet()`: 获取Map集合中所有的键，存储到Set集合中。5.public Set<Map.Entry<K,V>> entrySet()`: 获取到Map集合中所有的键值对对象的集合(Set集合)。说明：该方法表示获取Map集合中的所有的键值对，存放到单列集合Set中，键值对属于Map.Entry<K,V>类型6.public boolean containKey(Object key)`:判断该集合中是否有此键。 如果包含返回true，否则返回false7. int size() 返回此映射中的键-值映射关系数。 集合长度

5.Map的遍历

1.使用keySet方法遍历(了解)

• 该方式需要使用的方法：

 public V get(Object key)` 根据指定的键，在Map集合中获取对应的值。public Set<K> keySet()`: 获取Map集合中所有的键，存储到Set集合中。

• 图解
  
• 代码实现

package com.itheima.sh.map_iterator_02;import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;/*使用keySet方法遍历*/
public class KeySetDemo01 {public static void main(String[] args) {//1.创建集合对象Map<String, String> map = new HashMap<>();//2.添加数据map.put("黄晓明", "baby");map.put("邓超", "孙俪");map.put("汪峰", "章子怡");map.put("宝宝", "蓉蓉");//3.使用集合对象调用keySet方法获取所有的键即老公Set<String> keys = map.keySet();//4.遍历Set集合获取每个键for(Iterator<String> it = keys.iterator();it.hasNext();){//获取数据String key = it.next();//使用Map集合对象调用get方法根据key获取value老婆String value = map.get(key);System.out.println(key+"--"+value);}}
}

小结：

1.上述使用keySet方式迭代了集合两次。第一次是放到Iterator迭代器中，然后第二次是使用get方式。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kWZbdb4C-1592807422288)(/image-20200518111653376.png)]

2.使用entrySet方式遍历Map集合(掌握)

• 使用方法：

  • Map接口中的方法：

    public Set<Map.Entry<K,V>> entrySet()`: 获取到Map集合中所有的键值对对象的集合(Set集合)。说明：该方法表示获取Map集合中的所有的键值对，存放到单列集合Set中，键值对属于Map.Entry<K,V>
    

  • 使用Map.Entry接口中的方法：

    K getKey() 返回与此项对应的键。
    V getValue()  返回与此项对应的值。 
    

• 图解

  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bPIMRpdC-1592807422289)(/image-20200518112903000.png)]

• 代码演示

  package com.itheima.sh.map_iterator_02;import java.util.HashMap;
  import java.util.Iterator;
  import java.util.Map;
  import java.util.Set;/*使用entrySet方法遍历*/
  public class EntrySetDemo02 {public static void main(String[] args) {//1.创建集合对象Map<String, String> map = new HashMap<>();//2.添加数据map.put("黄晓明", "baby");map.put("邓超", "孙俪");map.put("汪峰", "章子怡");map.put("宝宝", "蓉蓉");//3.获取键值对整体对象放到Set集合中Set<Map.Entry<String, String>> entries = map.entrySet();//4.遍历单列集合Set取出每个键值对对象即结婚证for(Iterator<Map.Entry<String, String>> it = entries.iterator();it.hasNext();){//5.取出键值对整体Map.Entry<String, String> entry = it.next();//6.使用entry对象调用方法获取键和值String key = entry.getKey();String value = entry.getValue();//7.输出System.out.println(key+"---"+value);}}
  }

  小结：

  1.以后都使用这种，因为效率高，只迭代一次

  2.获取键值对整体属于Map.Entry类型，然后使用Map.Entry中的方法分别获取出key和value：

  K getKey() 返回与此项对应的键。
  V getValue()  返回与此项对应的值。 
  

6.Map常用子类

1.HashMap类(必须掌握)

1.HashMap类底层是一个哈希表数据结构，控制键

2.要求HashMap键位置的对象所属类必须重写hashCode和equals方法

3.HashMap集合是jdk1.2开始有的：

1）线程不安全
2) 效率高
3）键和值可以是null
4) 存取无序

代码演示：

package com.itheima.sh.hashmap_03;import java.util.HashMap;/*注意：底层哈希表控制键的，要求键位置的对象所属类必须重写hashCode和equals方法*/
public class HashMapDemo01 {public static void main(String[] args) {//1.创建集合对象HashMap() 构造一个具有默认初始容量 (16) 和默认加载因子 (0.75) 的空 HashMap。HashMap<Student, String> hm = new HashMap<Student, String>();//2.向集合添加数据hm.put(new Student("张三", 18), "上海");hm.put(new Student("李四", 20), "北京");hm.put(new Student("王五", 19), null);hm.put(null, null);hm.put(null, null);hm.put(null, null);hm.put(null, null);hm.put(null, null);hm.put(null, null);//修改作用hm.put(new Student("张三", 18), "黑龙江");//hm = {Student{name='王五', age=19}=null, null=null, Student{name='张三', age=18}=黑龙江, Student{name='李四', age=20}=北京}System.out.println("hm = " + hm);}
}

小结：

1.HashMap属于jdk1.2之后才有的，替换了Hashtable，提高效率

2.底层哈希表数据结构控制键，所以要求键位置的对象所属类必须重写hashCode和equals方法

3.HashMap集合的键和值都可以是null，但是键位置只能是一个null

2.Hashtable类(了解)

1.数据jdk1.0就有的

2.安全的，但是效率低

3.底层是哈希表数据结构，控制键

4.该集合的键和值不允许是null

5.从1.2开始后被HashMap取代了，效率更高

代码演示：

package com.itheima.sh.hashtable_04;import java.util.Hashtable;/*Hashtable类(了解)1.数据jdk1.0就有的2.安全的，但是效率低3.底层是哈希表数据结构，控制键4.该集合的键和值不允许是null5.从1.2开始后被HashMap取代了，效率更高*/
public class HashtableDemo01 {public static void main(String[] args) {//创建集合对象 Hashtable() 用默认的初始容量 (11) 和加载因子 (0.75) 构造一个新的空哈希表。Hashtable<String, Integer> ht = new Hashtable<>();//添加数据ht.put("刘德华", 50);ht.put("张学友", 55);ht.put("郭富城", 52);ht.put("黎明", 51);ht.put("刘德华", 48);//Exception in thread "main" java.lang.NullPointerException 报空指针异常/*Hashtable的键和值不能是null的原因：public synchronized V put(K key, V value) {// Make sure the value is not nullif (value == null) {throw new NullPointerException();}key是null的话这里相当于null.hashCode() 空指针了int hash = key.hashCode();}*/ht.put(null, 20);System.out.println("ht = " + ht);}
}

3.LinkedHashMap(了解)

package com.itheima.sh.linkedhashmap_05;import java.util.LinkedHashMap;/*LinkedHashMap1.底层有两个数据结构：1）哈希表：存储数据保证数据唯一2）双链表：保证存取有序*/
public class LinkedHashMapDemo01 {public static void main(String[] args) {//LinkedHashMap()构造一个带默认初始容量 (16) 和加载因子 (0.75) 的空插入顺序 LinkedHashMap 实例。LinkedHashMap<String, Integer> ht = new LinkedHashMap<>();ht.put("刘德华", 50);ht.put("张学友", 55);ht.put("郭富城", 52);ht.put("黎明", 51);ht.put("刘德华", 48);//ht = {刘德华=48, 张学友=55, 郭富城=52, 黎明=51}System.out.println("ht = " + ht);}
}

小结：

LinkedHashMap
1.底层有两个数据结构：
1）哈希表：存储数据保证数据唯一
2）双链表：保证存取有序

4.TreeMap类（了解）

1.底层是红黑树数据结构，控制键，可以对键进行排序。具体如何排序看使用的构造方法：

1) TreeMap() 对键是大小升序，非自定义类(String Integer)按照大小升序排序
2）TreeMap(Comparator<? super K> comparator) 根据键按照指定规则进行排序，参数：comparator属于自定义比较器接口Comparator类型，具体的排序规则由我们实现该接口的排序方法指定：int compare(T o1, T o2)  o1 - o2 升序o2 - o1 降序

代码演示：

package com.itheima.sh.treemap_06;import java.util.Comparator;
import java.util.TreeMap;/*1) TreeMap() 对键是大小升序，非自定义类(String Integer)按照大小升序排序,不能是自定义类，否则就会报ClassCastException2）TreeMap(Comparator<? super K> comparator) 根据键按照指定规则进行排序，参数：comparator属于自定义比较器接口Comparator类型，具体的排序规则由我们实现该接口的排序方法指定：int compare(T o1, T o2)o1 - o2 升序o2 - o1 降序*/
public class TreeMapDemo01 {public static void main(String[] args) {method_3();}//需求：按照年龄从小往大排private static void method_3() {//创建集合对象TreeMap<Student, String> tm = new TreeMap<>(new Comparator<Student>() {@Overridepublic int compare(Student o1, Student o2) {return o1.age - o2.age;}});//添加数据tm.put(new Student("张三", 20), "上海");tm.put(new Student("李四", 17), "杭州");tm.put(new Student("王五", 19), "北京");tm.put(new Student("张三", 20), "上海");System.out.println(tm);}//1.需求:按照整数的从大到小排序/*2）TreeMap(Comparator<? super K> comparator) 根据键按照指定规则进行排序，参数：comparator属于自定义比较器接口Comparator类型，具体的排序规则由我们实现该接口的排序方法指定：int compare(T o1, T o2)o1 - o2 升序o2 - o1 降序*/private static void method_2() {//1.创建集合对象TreeMap<Integer, String> tm = new TreeMap<>(new Comparator<Integer>() {@Overridepublic int compare(Integer o1, Integer o2) {return o2 - o1;}});//添加数据tm.put(50, "刘德华");tm.put(56, "张学友");tm.put(48, "郭富城");tm.put(53, "黎明");//tm = {56=张学友, 53=黎明, 50=刘德华, 48=郭富城}System.out.println("tm = " + tm);}//1) TreeMap() 对键是大小升序，非自定义类(String Integer)按照大小升序排序private static void method_1() {//1.创建集合对象TreeMap<String, String> tm = new TreeMap<>();//2.添加数据tm.put("abcdef", "刘德华");tm.put("ADDF", "张学友");tm.put("abc", "郭富城");tm.put("zhag", "黎明");//输出 tm = {ADDF=张学友, abc=郭富城, abcdef=刘德华, zhag=黎明}System.out.println("tm = " + tm);}
}

小结：

1. TreeMap() 对键是大小升序，非自定义类(String Integer)按照大小升序排序,不能是自定义类，否则就会报ClassCastException
   2）TreeMap(Comparator<? super K> comparator) 根据键按照指定规则进行排序，
   参数：comparator属于自定义比较器接口Comparator类型，具体的排序规则由我们实现该接口的排序方法指定：
   int compare(T o1, T o2)
   o1 - o2 升序
   o2 - o1 降序

7.Map集合练习(课下必须完成)

**需求：**计算一个字符串中每个字符出现次数。

代码演示：

package com.itheima.sh.map_test_07;import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;/*需求：计算一个字符串中每个字符出现次数。分析："akajahKLAK19"字符          次数a              3k              1j              1h              1K              1...................1.map集合没有字符那么直接将字符和次数1存储到map集合2.如果map集合中有字符，则根据字符获取次数然后加1，在存储到map集合中 put(a,3)步骤：1.创建键盘录入的对象2.获取录入的字符串3.创建Map集合对象，字符作为key  次数作为value4.遍历录入的字符串取出每个字符5.判断Map集合的key位置是否包含该字符不包含：说明是第一次操作该字符，将字符和次数1存储到集合中包含：说明不是第一次操作字符，将字符作为key结合value get(key)方法 获取次数，然后次数+1，最后将字符以及加1后的次数存储到map中6.遍历map集合输出字符和次数*/
public class Test01 {public static void main(String[] args) {//1.创建键盘录入的对象Scanner sc = new Scanner(System.in);//2.获取录入的字符串System.out.println("请您输入一个字符串:");String inputStr = sc.next();//3.创建Map集合对象，字符作为key  次数作为valueHashMap<Character, Integer> map = new HashMap<>();//4.遍历录入的字符串取出每个字符 inputStr.length().forifor (int i = 0; i < inputStr.length(); i++) {//i表示索引//获取字符char key = inputStr.charAt(i);// 5.判断Map集合的key位置是否包含该字符if(map.containsKey(key)){//包含：说明不是第一次操作字符，将字符作为key结合value get(key)方法// map中 获取次数，然后次数+1，最后将字符以及加1后的次数存储到//获取次数即valueInteger countValue = map.get(key);//然后次数+1countValue++;//最后将字符以及加1后的次数存储到map.put(key, countValue);}else{// 不包含：说明是第一次操作该字符，将字符和次数1存储到集合中map.put(key, 1);}}//6.遍历map集合输出字符和次数//获取键值对对象Set<Map.Entry<Character, Integer>> entries = map.entrySet();//遍历set集合for (Map.Entry<Character, Integer> entry : entries) { //entry表示键值对对象//获取keyCharacter key = entry.getKey();Integer value = entry.getValue();// \t 表示制表符 就是tabSystem.out.println("字符:\t"+key+"\t次数:\t"+value);}}
}

8.集合的嵌套(掌握)

集合首先只能存储引用数据类型，而集合本身就是引用数据类型，所以集合里面还可以继续存储集合。在java中各种集合可以各种嵌套。

1.List嵌套List

package com.itheima.sh.collection_map_contains_08;import java.util.ArrayList;
import java.util.Collections;/*需求：假如有两个班的学生姓名，它们分别存储在两个集合中，最后存储到一个集合中。举例：淘宝上买手机：卖家 装手机：先装里面的，最后装外面的(从里向外添加)买家拆手机： 先拆外面的，最后获取到里面的(从外往里获取)嵌套集合使用规律：添加数据：(从里向外添加)获取数据：(从外往里获取)*/
public class ListDemo01 {public static void main(String[] args) {//创建一个班的集合ArrayList<String> list1 = new ArrayList<>();//添加数据Collections.addAll(list1, "张三", "柳岩");ArrayList<String> list2 = new ArrayList<>();//添加数据
//        Collections.addAll(list2, "李四", "杨幂");//创建集合存储list1 list2//List套ListArrayList<ArrayList<String>> allList = new ArrayList<>();//将list1 list2存储到allList中//添加数据：(从里向外添加)Collections.addAll(allList, list1, list2);//遍历  获取数据：(从外往里获取)//先获取最外面的集合：allList  在获取里面的集合 list1 list2//先获取最外面的集合：allListfor (ArrayList<String> outList : allList) {//取出每个集合中的数据 第一次outList表示list1  第二次outList表示list2for (String s : outList) {System.out.println(s);}}}
}

小结：

1.嵌套集合使用规律：
添加数据：(从里向外添加)
获取数据：(从外往里获取)

2.List嵌套Map

package com.itheima.sh.collection_map_contains_08;import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;/*List嵌套Map集合需求：有两个班的学员，分别存储在两个Map中，然后将两个班的map存储到一个ArrayList中。*/
public class ListMapDemo02 {public static void main(String[] args) {//1.创建Map集合对象HashMap<String, String> map1 = new HashMap<>();map1.put("hiema001", "柳岩");map1.put("hiema002", "杨幂");HashMap<String, String> map2 = new HashMap<>();map2.put("itcast001", "郭德纲");map2.put("itcast002", "岳云鹏");//2.创建ArrayList集合对象ArrayList<HashMap<String, String>> list = new ArrayList<>();list.add(map1);list.add(map2);//3.遍历集合  添加：从里向外添加  获取：从外向里获取//3.1遍历list集合for (HashMap<String, String> m : list) {//3.2遍历map集合//3.2.1 获取键值对Set<Map.Entry<String, String>> entries = m.entrySet();//3.2.2 获取每个键值对for (Map.Entry<String, String> entry : entries) {//3.2.3 获取键和值String key = entry.getKey();String value = entry.getValue();//3.2.4 输出System.out.println(key+"----"+value);}}}
}

小结： 添加：从里向外添加 获取：从外向里获取

3.Map嵌套Map

package com.itheima.sh.collection_map_contains_08;import java.util.HashMap;
import java.util.Map;
import java.util.Set;/*Map集合嵌套Map需求： 有两个班，班号分别为："黑马188期"和"黑马189期"，两个班学员的姓名分别存储在两个Map中*/
public class MapMapDemo03 {public static void main(String[] args) {//1.创建Map集合对象保存学号和姓名HashMap<String, String> map1 = new HashMap<>();map1.put("hiema001", "柳岩");map1.put("hiema002", "杨幂");HashMap<String, String> map2 = new HashMap<>();map2.put("itcast001", "郭德纲");map2.put("itcast002", "岳云鹏");//2.创建Map集合保存班级和学号 姓名HashMap<String, HashMap<String, String>> allMap = new HashMap<>();allMap.put("黑马188期", map1);allMap.put("黑马189期", map2);//3.遍历map: 从外向里获取//3.1获取最外面集合的键值对对象Set<Map.Entry<String, HashMap<String, String>>> outEntries = allMap.entrySet();//3.2取出最外面集合中的每个键值对for (Map.Entry<String, HashMap<String, String>> outEntry : outEntries) {//3.3遍历outEntry表示的外面集合的key和valueString outKey = outEntry.getKey();System.out.println("班级是:"+outKey);//outValue表示 map1 map2HashMap<String, String> outValue = outEntry.getValue();//3.4遍历outValue表示的map集合Set<Map.Entry<String, String>> InEntries = outValue.entrySet();for (Map.Entry<String, String> inEntry : InEntries) {//获取inEntry集合的key和valueString key = inEntry.getKey();String value = inEntry.getValue();System.out.println(key+"---"+value);}}}
}

小结： 添加：从里向外添加 获取：从外向里获取

9.使用集合模拟斗地主游戏编写(课下必须完成)

• 图解

• 代码实现

  package com.itheima.sh.playcard_09;import java.util.ArrayList;
  import java.util.Collections;
  import java.util.HashMap;/*斗地主游戏编写：步骤：1.准备牌2.洗牌3.发牌4.看牌小☺*/
  public class PlayCard {public static void main(String[] args) {//1.准备牌//1.1创建map集合保存序号和扑克牌HashMap<Integer, String> mapPoker = new HashMap<>();//1.2创建集合保存序号ArrayList<Integer> numbersList = new ArrayList<>();//1.3创建集合存储花色ArrayList<String> colors = new ArrayList<>();Collections.addAll(colors, "♣", "♦", "♠", "♥");//1.4创建集合存储扑克牌数字ArrayList<String> numbers = new ArrayList<>();Collections.addAll(numbers, "2", "A", "K", "Q", "J");for (int i = 10; i >= 3; i--) {numbers.add(i+"");}//定义变量作为mapPoker序号int index = 0;//先向扑克牌中添加大小王mapPoker.put(index, "大☺");//每次序号+1index++;mapPoker.put(index, "小☺");//每次序号+1index++;//numbers = [2, A, K, Q, J, 10, 9, 8, 7, 6, 5, 4, 3]
  //        System.out.println("numbers = " + numbers);//1.5将花色和扑克牌的数字进行组合  ♣2 ♦2 ♠2 ♥2  ♣A ♦A ♠A ♥A//数字作为外层循环for (String thisNumber : numbers) {//颜色作为内层循环for (String thisColor : colors) {//拼接String thisCard = thisColor + thisNumber;//将扑克牌放到map集合中mapPoker.put(index,thisCard);//♣2//每次序号+1index++;}}//        System.out.println(mapPoker);//1.6添加序号for (int i = 0; i <= 53; i++) {numbersList.add(i);}
  //        System.out.println(numbersList);// 2.洗牌 洗序号Collections.shuffle(numbersList);//3.发牌 发的是序号//3.1创建三个玩家集合ArrayList<Integer> fage = new ArrayList<>();ArrayList<Integer> suoge = new ArrayList<>();ArrayList<Integer> yanyan = new ArrayList<>();ArrayList<Integer> dipai = new ArrayList<>();//3.2遍历序号集合numbersList取出每个序号for (int i = 0; i < numbersList.size(); i++) {//i表示索引//3.3取出每个序号Integer thisNumber = numbersList.get(i);// numbersList.get(i)表示根据索引i获取numbersList中的序号/*3.4 最后三张留作底牌 其余的牌分别发给三个玩家*///判断是否是最后三张底牌if(i>=numbersList.size() - 3){//51 52 53//说明是最后三张底牌 放到底牌集合中dipai.add(thisNumber);}else{//说明不是最后三张底牌/*3.5将其余牌发给玩家发哥 摸一张锁哥 摸第二张岩岩 摸第三张*/if(i % 3 == 0){//发哥fage.add(thisNumber);}else if(i % 3 == 1){//锁哥suoge.add(thisNumber);}else if(i % 3 == 2){//岩岩yanyan.add(thisNumber);}}}//4.对玩家以及底牌排序Collections.sort(fage);Collections.sort(suoge);Collections.sort(yanyan);Collections.sort(dipai);//5.看牌lookCard(mapPoker,fage,"发哥");lookCard(mapPoker,suoge,"锁哥");lookCard(mapPoker,yanyan,"岩岩");lookCard(mapPoker,dipai,"底牌");}/*mapPoker:存放的序号和扑克牌0  大王1  小王list:存放的是玩家序号  10 20 25name:接收的名字*/private static void lookCard(HashMap<Integer, String> mapPoker, ArrayList<Integer> list, String name) {//创建StirngBuilder对象StringBuilder sb = new StringBuilder(name).append(":");//遍历list集合取出每个序号for (Integer key : list) {//根据key获取value即扑克牌String value = mapPoker.get(key);//将value即扑克牌放到缓冲区中sb.append(value).append("\t");}System.out.println(sb);}
  }