反馈和复习

a.比较器口诀: 升序 前-后(源码)
b.为什么保证元素的唯一性.重写hashCode和equals
    因为Hash表结构,底层就是根据hashCode和equals来判断两个元素是否重复
1.Collection: 7+1
2.List: 7+1+4
    ArrayList: 7+1+4
    LinkedList: 7+1+4+8
3.Set:7+1
    HashSet:7+1   无序
    LinkedHashSet:7+1 有序
    TreeSet:7+1 无序(有自然顺序的)
4.Collections    
     shuffle(List list); 打乱集合顺序
     sort(List list); 对集合元素进行排序(默认升序)
     sort(List list,Comparator 比较器); 自定义排序规则(升序 前-后)

今日内容

• Map集合(和Collection没有直接联系)
• 集合的嵌套(集合的元素还是集合)
• 斗地主发牌案例[重要]
• 冒泡排序算法(a,算法过程 b,算法的代码实现)

Map集合(接口)[重点]

概述

所有实现类都没有特有方法 ,是个双列集合

特点:

• Collection<E>泛型只有一个, Map<K,V>泛型有两个
• Collection 中的集合，元素是孤立存在的（理解为单身），向集合中存储元素采用一个个元素的方式存储。
• Map 中的集合，元素是成对存在的(理解为夫妻)。每个元素由键与值两部分组成，通过键可以找对所对应的
  值。
• Collection 中的集合称为单列集合， Map 中的集合称为双列集合。
  注意 Map 中的集合不能包含重复的键，值可以重复；每个键只能对应一个值。

Map的实现类及其特点

Map接口三个常见的实现类:

• HashMap 底层采用哈希表结构 无序
• LinkedHashMap 底层采用链表+哈希表结构 有序 (单列链表结构)
• TreeMap 底层采用红黑树结构 无序,但是键有自然顺序.可以对元素的键进行排序，排序方式有两种:自然排序和比较器排序

重点:
Map中为了保证键的唯一性, 如果键是自定义类型,必须重写键的hashCode和equals方法

Map的通用方法

• 增: public V put(K key, V value); 添加一个键值对,返回值类型为V, 返回的就是null
• 删:public V remove(Object key);根据键删除键值对,返回值类型为 V
• 改: 用的就是增的方法, put(K key, Value);因为键是唯一的, 添加重复的键,就相当于是修改原键所对应的值了.
• 查:public V get(Object key) ;根据键获取对应的值,返回值类型为 V
• 其他:
  public Set<K> keySet() : 获取Map集合中所有的键，存储到Set集合中。
  public Set<Map.Entry<K,V>> entrySet() : 获取到Map集合中所有的键值对对象的集合(Set集合)。
  public boolean containKey(Object key) :判断该集合中是否有此键

tips:
使用put方法时，若指定的键(key)在集合中没有，则没有这个键对应的值，返回null，并把指定的键值添加到集合中；
若指定的键(key)在集合中存在，则返回值为集合中键对应的值（该值为替换前的值），并把指定键所对应的值，替换成指定的新值。

Map的遍历[非常重要]

迭代器,增强for,for循环都不可用. 因为 Map和Collection没有关系, 没有索引

• 遍历方式一以键找值
  1.获取Map中所有的键，由于键是唯一的，所以返回一个Set集合存储所有的键。方法提示: keyset()
  2.遍历键的Set集合，得到每一个键。
  3.根据键，获取键所对应的值。方法提示: get(K key)

  
  

第一种方式称为:以键找值
public class TestMap01 {
    public static void main(String[] args) {
        //第一种遍历方式:以键找值
        //1.创建一个Map的实现类对象
        HashMap<String, Integer> map = new HashMap<String, Integer>();
        //2.添加几个
        map.put("张三", 18);
        map.put("李四", 28);
        map.put("王五", 38);
        map.put("赵六", 48);
        map.put("前妻", 8);
        map.put("王八", 88);
        //3.获取所有的键
        Set<String> keys = map.keySet();
        //4.遍历这个keys集合
        for (String key : keys) {
            //5.以键找值
            Integer value = map.get(key);
            System.out.println(key + "..." + value);
        }
    }
}    

• 遍历方式二键值对方式
  Entry键值对对象:
  Map 中存放的是两种对象，一种称为key(键)，一种称为value(值)，它们在在 Map 中是一一对应关系，这一对对象又称做 Map 中的一个 Entry(项) 。 Entry 将键值对的对应关系封装成了对象。即键值对对象，这样我们在遍历 Map 集合时，就可以从每一个键值对（ Entry ）对象中获取对应的键与对应的值。
  在Map集合中也提供了获取所有Entry对象的方法：
  public Set<Map.Entry<K,V>> entrySet() : 获取到Map集合中所有的键值对对象的集合(Set集合)。
  获取了Entry对象 , 表示获取了一对键和值，那么同样Entry中 , 分别提供了获取键和获取值的方法：
  public K getKey() ：获取Entry对象中的键。
  public V getValue() ：获取Entry对象中的值。

第二种方式称为:键值对方式
public class TestMap02 {
    public static void main(String[] args) {
        //第一种遍历方式:以键找值
        //1.创建一个Map的实现类对象
        HashMap<String, Integer> map = new HashMap<String, Integer>();
        //2.添加几个
        map.put("张三", 18);
        map.put("李四", 28);
        map.put("王五", 38);
        map.put("赵六", 48);
        //Map集合遍历的第二种方式:键值对方式
        //3.获取Map中所有的键值对
        Set<Map.Entry<String, Integer>> entries = map.entrySet();
        //4.遍历这个entries集合
        for (Map.Entry<String, Integer> entry : entries) {
            //5.从entry中取出键和值
            String key = entry.getKey();
            Integer value = entry.getValue();
            //6.打印
            System.out.println(key+"..."+value);
        }
    }
}
    

HashMap存储自定义类型

HashMap存储键位自定义类型时,必须在自定义类型中重写hash和equals方法

需求:
    创建一个Map,学生作为键, 家庭住址作为值。
    HashMap<Student,String>
public class TestDemo {
    public static void main(String[] args) {
        //创建一个Map,学生作为键, 家庭住址作为值。
        //1.创建集合
        HashMap<Student,String> map = new HashMap<Student, String>();
        //2.添加数据
        map.put(new Student("jack",12),"北京中关村");
        map.put(new Student("rose",16),"南京中关村");
        map.put(new Student("marry",20),"天津中关村");
        map.put(new Student("tom",12),"东京中关村");
        //3.打印
        //{Student{name=jack,age=12}="北京中关村",键=值,键=值,键=值}
        System.out.println(map);
        //4.我要修改rose的地址
        map.put(new Student("rose",16),"广东东莞");
        System.out.println(map);
    }
}
结论:
    如果键是自定义类型,为了保证键的唯一性,必须重写hashCode和equals方法     

LinkedHashMap介绍

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());
        }
    }
}

TreeMap集合

TreeMap底层采用红黑树结构
TreeMap也是无序的, 会按照键的自然顺序默认升序
如果存储的键为自定义类型,则必须使用比较器进行排序,否则TreeMap的自然顺序会不知道按照对象的什么来排序.

public static void main(String[] args) {
    TreeMap<Integer, String> map = new TreeMap<Integer, String>();
    map.put(1,"张三");
    map.put(4,"赵六");
    map.put(3,"王五");
    map.put(6,"酒八");
    map.put(5,"老七");
    map.put(2,"李四");
    System.out.println(map);
}
 
控制台的输出结果为:
{1=张三, 2=李四, 3=王五, 4=赵六, 5=老七, 6=酒八}

自然排序

扩展:
Arrays.sort | Collections.sort
| TreeSet | TreeMap 按照如下进行
如果键是数值类型,按照键值大小升序排序,如果是字符串类型, 先按照首字母码值,再按次字母码值

如果想要采用从大到小等自定义规则排序, 则使用比较器Comparator 排序就可以

在TreeMap中可以使用如下代码,使用其构造方法

public class Student {
    private int age;
    private String name;
    //省略get/set..
    public Student() {}
    public Student(int age, String name) {
        this.age = age;
        this.name = name;
    }
    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
    @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(age, name);
    }
}
public static void main(String[] args) {
    TreeMap<Student, String> map = new TreeMap<Student, String>(new Comparator<Student>
() {
        @Override
        public int compare(Student o1, Student o2) {
            //先按照年龄升序
            int result = o1.getAge() - o2.getAge();
            if (result == 0) {
                //年龄相同,则按照名字的首字母升序
                return o1.getName().charAt(0) - o2.getName().charAt(0);
            } else {
                //年龄不同,直接返回结果
                return result;
            }
        }
    });
    map.put(new Student(30, "jack"), "深圳");
    map.put(new Student(10, "rose"), "北京");
    map.put(new Student(20, "tom"), "上海");
    map.put(new Student(10, "marry"), "南京");
    map.put(new Student(30, "lucy"), "广州");
    System.out.println(map);
}
控制台的输出结果为:
{
  Student{age=10, name='marry'}=南京, 
  Student{age=10, name='rose'}=北京, 
  Student{age=20, name='tom'}=上海, 
  Student{age=30, name='jack'}=深圳, 
  Student{age=30, name='lucy'}=广州
}

Map集合练习[重点]

需求: 输入一个字符串中每个字符出现次数。

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嵌套List

public class Test{
    public static void main(String[] args){
        /*
            假如有两个班的学生姓名，它们分别存储在两个集合中：
        */
        //第一个班
        ArrayList<String> list1 = new ArrayList<>();
        list1.add("迪丽热巴");
        list1.add("古力娜扎");
        list1.add("柳岩");
        list1.add("杨幂");
        
        //第二个班
        ArrayList<String> list2 = new ArrayList<>();
        list2.add("蔡徐坤");
        list2.add("杨坤");
        list2.add("陈伟霆");
        list2.add("李易峰");
        
        //将两个集合存储到一个集合中
        ArrayList<ArrayList<String>> allList = new ArrayList<>();
        allList.add(list1);
        allList.add(list2);
        
        System.out.println(allList);
        //遍历allList，取出每个ArrayList
        for(ArrayList<String> list : allList){
            //遍历每个班的ArrayList
            for(String s : list){
                System.out.println(s);
            }
        }
    }
    
}
 

List嵌套Map

public class Test{
    public static void main(String[] args){
        /*
            有两个班的学员，分别存储在两个Map中
        */
        //第一个班：
        Map<String,String> map1 = new HashMap<>();
        map1.put("it001","迪丽热巴");
        map1.put("it002","古力娜扎");
        
        //第二个班：
        Map<String,String> map2 = new HashMap<>();
        map2.put("heima001","蔡徐坤");
        map2.put("heima002","李易峰");
        
        //将两个班的map存储到一个ArrayList中
        ArrayList<Map<String,String>> allList = new ArrayList<>();
        allList.add(map1);
        allList.add(map2);
        
        //遍历allList，取出每个Map
        for(Map<String,String> map : allList){
            //遍历map
            Set<String> keys = map.keySet();
            for(String key : keys){
                System.out.println(key + " - " + map.get(key));
            }
        }
    }

Map嵌套Map

public class Test{
    public static void main(String[] args){
        /*
        有两个班，班号分别为："黑马188期"和"黑马189期"，两个班学员的姓名分别存储在两个Map中
        */
        //"黑马188期"：
        Map<String,String> map1 = new HashMap<>();
        map1.put("it001","迪丽热巴");
        map1.put("it002","古力娜扎");
        
        //"黑马189期"：
        Map<String,String> map2 = new HashMap<>();
        map2.put("heima001","蔡徐坤");
        map2.put("heima002","李易峰");
        
        //将两个班的Map连同对应的"班号"一同存储在一个Map中
        Map<String,Map<String,String>> allMap = new HashMap<>();
        allMap.put("黑马188期",map1);
        allMap.put("黑马189期",map2);
        
        //遍历allMap
        Set<String> keys = allMap.keySet();
        for(String k : keys){
            System.out.println(k + "：");
            //取出对应的map
            Map<String,String> map = allMap.get(k);
            //遍历map
            Set<String> keys2 = map.keySet();
            for(String k2 : keys2){
                System.out.println(k2 + " = " + map.get(k2));
            }
        }
    }
}

模拟斗地主洗牌发牌[重点]

案例介绍

需求: 模拟斗地主发牌,看牌(但是不打牌)

图解斗地主洗牌

分析

步骤分析:
1.准备 编号和牌 组成的Map集合
2.准备一副牌(54个编号)
3.洗牌(打乱集合)
4.发牌(遍历集合)
5.排序(sort方法)
6.转牌(以键找值)
7.打印给用户看

斗地主洗牌代码实现

public class TestDouDiZhu {
    public static void main(String[] args) {
        //1.准备 编号和牌 组成的Map集合
        LinkedHashMap<Integer, String> map = new LinkedHashMap<Integer, String>();
        //a.花色 4种
        String[] colors = {"♠", "♥", "♣", "♦"};
        //b.数值 13种
        String[] nums = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"};
        //c.编号变量
        int id = 1;
        //d.组合牌
        for (String num : nums) {
            for (String color : colors) {
                String card = color + num;
                //保存到map集合中
                map.put(id, card);
                id++;
            }
        }
        //e.单独添加大小王
        map.put(53, "小S");
        map.put(54, "大S");

        //2.准备一副牌(54个编号)
        ArrayList<Integer> cards = new ArrayList<Integer>();
        for (int i = 1; i < 55; i++) {
            cards.add(i);
        }
        //3.洗牌(打乱集合)
        Collections.shuffle(cards);
        //4.发牌(遍历集合)
        ArrayList<Integer> player1 = new ArrayList<Integer>();
        ArrayList<Integer> player2 = new ArrayList<Integer>();
        ArrayList<Integer> player3 = new ArrayList<Integer>();
        ArrayList<Integer> diPai = new ArrayList<Integer>();
        //遍历集合
        //此处不能使用增强for
        for (int i = 0; i < cards.size() - 3; i++) {
            //取出每一张牌
            Integer card = cards.get(i);
            //给谁呢?????????????????????????????????
            //i = 0 3 6 p1
            //i = 1 4 7 p2
            //i = 2 5 8 p3
            if (i % 3 == 0) {
                player1.add(card);
            } else if (i % 3 == 1) {
                player2.add(card);
            }else{
                player3.add(card);
            }
        }

        //最后张三留给底牌
        diPai.add(cards.get(53));
        diPai.add(cards.get(52));
        diPai.add(cards.get(51));
        //5.排序(sort方法)
        Collections.sort(player1);
        Collections.sort(player2);
        Collections.sort(player3);
        Collections.sort(diPai);

        //6.看牌
        lookCards(player1,map);
        lookCards(player2,map);
        lookCards(player3,map);
        lookCards(diPai,map);

    }
    //看牌方法
    public static void lookCards(ArrayList<Integer> idCards, LinkedHashMap<Integer, String> map) {
        //遍历
        for (Integer idCard : idCards) {
            String card = map.get(idCard);
            System.out.print(card+" ");
        }
        System.out.println();
    }
}

冒泡排序算法(工具类已经写好了)

介绍

• 依次比较相连的两个元素,大的放后边
• 如果有n个数据进行排序，总共需要比较n-1轮(每一轮是指, 如 数组中5个数, 0和1,1和2,2和3,3和4 才算一轮)
• 每一轮比较完毕，下一轮的比较就会少一个数据参与

n个数据一共执行 n-1轮, 每一轮, 需要执行 n-1次

过程图解

冒泡排序动态图.gif

代码实现

/*
    冒泡排序：
        一种排序的方式，对要进行排序的数据中相邻的数据进行两两比较，将较大的数据放在后面，
        依次对所有的数据进行操作，直至所有数据按要求完成排序
 */
public class ArrayDemo {
    public static void main(String[] args) {
        //定义一个数组
        int[] arr = {7, 6, 5, 4, 3};
        System.out.println("排序前：" + Arrays.toString(arr));
 
        // 这里减1，是控制每轮比较的次数
        for (int x = 0; x < arr.length - 1; x++) {
            // -1是为了避免索引越界，-x是为了调高比较效率
            for (int i = 0; i < arr.length - 1 - x; i++) {
                  //如果前>后   
                  if (arr[i] > arr[i + 1]) {
                    int temp = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = temp;
                }
            }
        }
        System.out.println("排序后：" + Arrays.toString(arr));
    }
}

数结构特点小结

数组特点：查询快，增删慢

单向链表特点：查询慢，增删快

栈特点：先进后出

队列特点：先进先出

哈希表特点：查询速度快

今日小结

1.Map接口定义的共性方法【必须掌握】
        put(键,值);
        remove(键);
        put(重复的键,值);
        get(键)
            
        containsKey(键);
        containsValue(值);
2.Map各种实现类的遍历方式(a.以键找值 b.键值对方式)【必须掌握】
        a.以键找值
            Set<K> keys = map.keySet(); //获取所有键的集合
            for(K key : keys){ //遍历所有的键
                V value = map.get(key)//以键找值
                //打印
                sout(key,value);    
            }
        b.键值对方式
            Set<Map.Entry<K,V>> entrys = map.entrySet();//获取所有的键值对的集合
            for(Map.Entry<K,V> entry : entrys){//遍历这个键值对集合
                K key = entry.getKey();//获取键值对中的键和值  
                V value = entry.getValue();//获取键值对中的键和值  
                //打印
                sout(key,value);   
            }
    
3.集合嵌套【难点，开发中见的不多】
    a。List套List：
        ArrayList<ArrayList<String>> arr;
    b。List套Map
        ArrayList<HashMap<String,Integer>> map
    c。Map套Map
        HashMap<String,HashMap<String,Integer>> map
4.斗地主牌【必须掌握】
    至少3遍!!!    
    
5.冒泡排序【理解】
      a。理解冒泡过程
      b。算法背下来
            for(int i = 0;i<arr.length-1;i++){
                for(int j = 0;j<arr.length-1-i;j++){
                    if(arr[j]>arr[j+1]){
                        int temp = arr[j];
                        arr[j] = arr[j+1];
                        arr[j+1] = temp;
                    }
                }  
            }
    ```