JAVA SE — Day 20

最新推荐文章于 2018-08-07 20:04:39 发布

娇小妖

最新推荐文章于 2018-08-07 20:04:39 发布

阅读量196

点赞数

分类专栏： java-se-基础 Map

本文链接：https://blog.csdn.net/yanqing_happy/article/details/78850682

版权

java-se-基础同时被 2 个专栏收录

22 篇文章 1 订阅

订阅专栏

Map

1 篇文章 0 订阅

订阅专栏

第1章 Map接口
1.1 Map接口概述
1.2 Map接口中常用集合概述
1.3 Map接口中的常用方法
1.4 Map集合遍历键找值方式
1.5 Entry键值对对象
1.6 Map集合遍历键值对方式
1.7 HashMap存储自定义类型键值
1.8 静态导入
1.9 可变参数
1.10 Collections集合工具类
1.11 集合嵌套
1.12 集合继承体系的面向对象思想
第2章模拟斗地主洗牌发牌
2.1 案例介绍
2.2 案例需求分析
2.3 实现代码步骤
第3章总结

第1章 Map接口

1.1 Map接口概述

我们通过查看Map接口描述，发现Map接口下的集合与Collection接口下的集合，它们存储数据的形式不同，如下图:
- Collection中的集合，元素是孤立存在的（理解为单身），向集合中存储元素采用一个个元素的方式存储。
- Map中的集合，元素是成对存在的(理解为夫妻)。每个元素由键与值两部分组成，通过键可以找对所对应的值。
- Collection中的集合称为单列集合，Map中的集合称为双列集合。
- 需要注意的是，Map中的集合不能包含重复的键，值可以重复；每个键只能对应一个值。
- Map中常用的集合为HashMap集合、LinkedHashMap集合。

这里写图片描述

1.2 Map接口中常用集合概述

Map有多个子类，这里我们主要讲解常用的HashMap集合、LinkedHashMap集合
- HashMap集合:存储数据采用的哈希表结构，元素的存取顺序不能保证一致。由于要保证键的唯一、不重复，需要重写键的hashCode()方法、equals()方法.
- LinkedHashMap集合:HashMap下有个子类LinkedHashMap，存储数据采用的哈希表结构+链表结构。通过链表结构可以保证元素的存取顺序一致；通过哈希表结构可以保证的键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。
- 注意：Map接口中的集合都有两个泛型变量K、V在使用时，要为两个泛型变量赋予数据类型。两个泛型变量K,V的数据类型可以相同，也可以不同。

1.3 Map接口中的常用方法

这里写图片描述

（1） V put(K,V): K作为键的对象, V作为值的对象，返回值为V

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

import java.util.HashMap;
import java.util.Map;

/*
 *  Map接口中的常用方法
 *    使用Map接口的实现类 HashMap
 */
public class MapDemo {
    public static void main(String[] args) {
        function();
    }
    /*
     *  将键值对存储到集合中
     *  V put(K,V): K作为键的对象, V作为值的对象，返回值为V
     *  
     *  存储的是重复的键,将原有的值,覆盖
     *  
     *  返回值：
     *  一般情况下返回null,
     *  存储重复键的时候,返回被覆盖之前的值
     */
    public static void function(){
        //创建集合对象,HashMap,存储对象,键是字符串,值是整数
        Map<String, Integer> map = new HashMap<String, Integer>();
        map.put("a", 1);

        Integer i = map.put("b", 2);
        System.out.println(i);//输出结果为：null   →→一般情况下返回值为null

        map.put("c", 3);
        Integer n = map.put("c", 5);//存储重复的键,会覆盖原有键的值   →→所以最终c的值为5
        System.out.println(n);//输出结果为：3    →→存储重复键的情况下,返回值为被覆盖之前的值 

        System.out.println(map);//输出结果为：{a=1, b=2, c=5}
    }
}

（2） V get(K):K作为键的对象, V作为值的对象，返回值为V

获取指定键(key)所对应的值(value)

import java.util.HashMap;
import java.util.Map;

public class MapDemo{
    public static void main(String[] args) {
        function();
    }
    /*
     * 通过键对象,获取值对象
     * V get(K)：输入键，返回值
     * 如果集合中没有这个键,返回null
     */
    public static void function(){
        //创建集合对象,作为键的对象整数,值的对象存储字符串
        Map<Integer,String> map = new HashMap<Integer, String>();
        map.put(1, "a");
        map.put(2, "b");
        map.put(3, "c");
        System.out.println(map);//输出结果为：{1=a, 2=b, 3=c}

        String value1 = map.get(2);
        System.out.println(value1);//输出结果为：b
        String value2 = map.get(5);
        System.out.println(value2);//输出结果为：null
    }

}

（3） V remove(K): K作为键的对象, V作为值的对象，返回值为V

根据指定的键(key)删除元素，返回被删除元素的值(value)

import java.util.HashMap;
import java.util.Map;

public class MapDemo2 {
    public static void main(String[] args) {
        function();
    }

    /*
     *  移除集合中的键值对,返回被移除之前的值
     *  V remove(K) ：传键返回值
     *  
     *  如果移除的键不存在，则返回值为null，原map元素不变
     */
    public static void function(){
        Map<Integer,String> map = new HashMap<Integer, String>();
        map.put(1, "a");
        map.put(2, "b");
        map.put(3, "c");
        System.out.println(map);//输出结果为：{1=a, 2=b, 3=c}

        String value = map.remove(3);
        System.out.println(value);//输出结果为：c
        System.out.println(map);//输出结果为：{1=a, 2=b}
    }
}

1.4 Map集合遍历键找值方式

键找值方式：即通过元素中的键，获取键所对应的值

这里写图片描述

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
/*
 *  Map集合的遍历
 *    map不能直接遍历（迭代器和for循环都不能使用），只能借助set
 *    利用键获取值
 *    Map接口中定义方法keySet
 *    所有的键,存储到Set集合
 */
public class MapDemo1 {
    public static void main(String[] args) {
        /*
         *  1. 调用map集合的方法keySet,所有的键存储到Set集合中
         *  2. 遍历Set集合,获取出Set集合中的所有元素 (Map中的键)
         *  3. 调用map集合方法get,通过键获取到值
         */
        Map<String,Integer> map = new HashMap<String,Integer>();
        map.put("a", 11);
        map.put("b", 12);
        map.put("c", 13);
        map.put("d", 14);
        //方法一：迭代器遍历
        //1. 调用map集合的方法keySet,所有的键存储到Set集合中
        Set<String> set = map.keySet();
        //2. 遍历Set集合,获取出Set集合中的所有元素 (Map中的键)
        Iterator<String> it = set.iterator();
        while(it.hasNext()){
            //it.next返回是Set集合元素,也就是Map中的键
            //3. 调用map集合方法get,通过键获取到值
            String key = it.next();
            Integer value = map.get(key);
            System.out.println(key+"...."+value); 
        }   //输出结果为：a....11
            //         b....12
            //         c....13
            //         d....14

        System.out.println("=======================");

        //方法二：增强for遍历
        for(String key : map.keySet()){
            Integer value = map.get(key);
            System.out.println(key+"...."+value);
        }   //输出结果为：a....11
            //         b....12
            //         c....13
            //         d....14
    }
 }

1.5 Entry键值对对象

在Map类设计时，提供了一个嵌套接口：Entry。Entry将键值对的对应关系封装成了对象。即键值对对象，这样我们在遍历Map集合时，就可以从每一个键值对（Entry）对象中获取对应的键与对应的值。
Entry是Map接口中提供的一个静态内部嵌套接口。
getKey()方法：获取Entry对象中的键
getValue()方法：获取Entry对象中的值
entrySet()方法：用于返回Map集合中所有的键值对(Entry)对象，以Set集合形式返回。
- 图解：

1.6 Map集合遍历键值对方式

（1）Map集合遍历方式entrySet方法：

    /*  Map集合获取方式
     *  entrySet方法,键值对映射关系(结婚证)获取
     *  实现步骤:
     *    1. 调用map集合方法entrySet()将集合中的映射关系对象,存储到Set集合
     *        Set<Entry <K,V> >
     *    2. 迭代Set集合
     *    3. 获取出的Set集合的元素,是映射关系对象
     *    4. 通过映射关系对象方法 getKet, getValue获取键值对
     *    
     *    创建内部类对象 外部类.内部类 = new 
     */
    public class MapDemo2 {
        public static void main(String[] args) {
            Map<Integer,String> map = new HashMap<Integer, String>();
            map.put(1, "abc");
            map.put(2, "bcd");
            map.put(3, "cde");
            //1. 调用map集合方法entrySet()将集合中的映射关系对象,存储到Set集合
            //此处直接写成Set<Entry>则会报错，Entry不是一种类型，必须用外部类接口.内部接口才可以。
            Set<Map.Entry <Integer,String> >  set = map.entrySet();
            //2. 迭代Set集合
            Iterator<Map.Entry <Integer,String> > it = set.iterator();
            while(it.hasNext()){
                //  3. 获取出的Set集合的元素,是映射关系对象
                // it.next 获取的是什么对象,也是Map.Entry对象
                Map.Entry<Integer, String> entry = it.next();
                //4. 通过映射关系对象方法 getKet, getValue获取键值对
                Integer key = entry.getKey();
                String value = entry.getValue();
                System.out.println(key+"...."+value);
            }


        }
    }

（2）Map集合遍历方式增强for循环：

 public class MapDemo2 {
        public static void main(String[] args) {
            Map<Integer,String> map = new HashMap<Integer, String>();
            map.put(1, "abc");
            map.put(2, "bcd");
            map.put(3, "cde");
            //1. 调用map集合方法entrySet()将集合中的映射关系对象,存储到Set集合
            Set<Map.Entry <Integer,String> >  set = map.entrySet();
            //2. 迭代Set集合
            Iterator<Map.Entry <Integer,String> > it = set.iterator();
            while(it.hasNext()){
                //  3. 获取出的Set集合的元素,是映射关系对象
                // it.next 获取的是什么对象,也是Map.Entry对象
                Map.Entry<Integer, String> entry = it.next();
                //4. 通过映射关系对象方法 getKet, getValue获取键值对
                Integer key = entry.getKey();
                String value = entry.getValue();
                System.out.println(key+"...."+value);
            }

            System.out.println("=========================");
            for(Map.Entry<Integer, String> entry : map.entrySet()){
                System.out.println(entry.getKey()+"..."+entry.getValue());
            }
        }
      }

注意：Map集合不能直接使用迭代器或者foreach进行遍历。但是转成Set之后就可以使用了。

1.7 HashMap存储自定义对象及遍历

（1）HashMap集合存储和遍历：

     /*
      *  使用HashMap集合,存储自定义的对象
      *  自定义对象,作为键,出现,作为值出现
      */
     public class HashMapDemo {
        public static void main(String[] args) {
            function_1();
        }
        /*
         * HashMap 存储自定义的对象Person,作为值出现
         * 键的对象,是字符串,可以保证唯一性
         */
        public static void function(){
            HashMap<String, Person> map = new HashMap<String, Person>();
            map.put("beijing", new Person("a",20));
            map.put("tianjin", new Person("b",18));
            map.put("shanghai", new Person("c",19));
            for(String key : map.keySet()){
                Person value = map.get(key);
                System.out.println(key+"..."+value);
            }
            //输出：tianjin...Person b... 18
            //     beijing...Person a ...20
            //     shanghai...Peron c ...19
            System.out.println("=================");
            for(Map.Entry<String, Person> entry : map.entrySet()){
                String key = entry.getKey();
                Person value = entry.getValue();
                System.out.println(key+"..."+value);
                //输出：tianjin...Person b... 18
                //     beijing...Person a ...20
                //     shanghai...Peron c ...19
            }
        }
        /*
         * HashMap 存储自定义对象Person,作为键出现
         * 键的对象,是Person类型,值是字符串
         * 保证键的唯一性,存储到键的对象,重写hashCode equals
         */
        public static void function_1(){
            HashMap<Person, String> map = new HashMap<Person, String>();
            map.put(new Person("a",20), "里约热内卢");
            map.put(new Person("b",18), "索马里");
            map.put(new Person("c",19), "百慕大");
            for(Person key : map.keySet()){
                String value = map.get(key);
                System.out.println(key+"..."+value);
                //输出：Person b...18...索马里
                 //    Person c...19...百慕大
                 //    Person a...20...里约热内卢
            }
            System.out.println("===================");
            for(Map.Entry<Person, String> entry : map.entrySet()){
                System.out.println(entry.getKey()+"..."+entry.getValue());
                //输出：Person b...18...索马里
                //     Person c...19...百慕大
                //     Person a...20...里约热内卢
            }
        }
     }

重写Person类的hashCode()：

public class Person {
    private String name;
    private int age;



    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Person other = (Person) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }
    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;
    }
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public Person() {
        super();

    }
    @Override
    public String toString() {
        return "Person " + name  +"...."+ age ;
    }

}

（2）LinkedHashMap的特点

  /*
       *  LinkedHashMap继承HashMap
       *  保证迭代的顺序
       */
      public class LinkedHashMapDemo {
        public static void main(String[] args) {
            LinkedHashMap<String, String> link = new LinkedHashMap<String, String>();
            link.put("1", "a");
            link.put("13", "a");
            link.put("15", "a");
            link.put("17", "a");
            System.out.println(link);
            //输出：{1=a,13=a,15=a,17=a}
        }
      }

（3）Hashtable的特点

   /*
        *  Map接口实现类 Hashtable
        *  底层数据结果哈希表,特点和HashMap是一样的
        *  Hashtable 线程安全集合,运行速度慢
        *  HashMap 线程不安全的集合,运行速度快
        *  
        *  Hashtable命运和Vector是一样的,从JDK1.2开始,被更先进的HashMap取代
        *  
        *  HashMap 允许存储null值,null键
        *  Hashtable 不允许存储null值,null键
        *  
        *  Hashtable他的孩子,子类 Properties 依然活跃在开发舞台
        */
       public class HashtableDemo {
        public static void main(String[] args) {    
            Map<String,String> map1 = new Hashtable<String,String>();
            map1.put(null, null);
            System.out.println(map);//报错
            Map<String,String> map2 = new HashMap<String,String>();
            map2.put(null, null);
            System.out.println(map);
        }
       }

1.8 静态导入

静态导入:如果本类中有和静态导入的同名方法会优先使用本类的
如果还想使用静态导入的,依然需要类名来调用

       /*
        * JDK1.5新特性,静态导入
        * 减少开发的代码量
        * 标准的写法,导入包的时候才能使用
        * 
        * import static java.lang.System.out;最末尾,必须是一个静态成员
        */
       import static java.lang.System.out;
       import static java.util.Arrays.sort;


       public class StaticImportDemo {
        public static void main(String[] args) {
            out.println("hello");

            int[] arr = {1,4,2};
            sort(arr);//等于Array.sort(arr);
        }
       }

1.9 可变参数

（1）方法的可变参数

   /*
      *  JDK1.5新的特性,方法的可变参数
      *  前提: 方法参数数据类型确定,参数的个数任意
      *  可变参数语法: 数据类型...变量名
      *  可变参数,本质就是一个数组
      */
     public class VarArgumentsDemo {
        public static void main(String[] args) {
            //调用一个带有可变参数的方法,传递参数,可以任意
            // getSum3();则返回7,说明是个数组

            int sum = getSum4(5,34,3,56,7,8,0);
            System.out.println(sum);

        }
        /*
         * 定义方法,计算2个整数和
         */
        public static int getSum1(int a,int b){
            return a+b;
        }
            /*
         * 定义方法,计算3个整数和
         */
        public static int getSum2(int a,int b ,int c){
            return a+b+c;
        }
        //以上方法不可取的原因是，需求改变时，方法就废掉了
        //所以利用可变参数实现
        /*
         * 定义方法,计算10个整数和
         * 方法的可变参数实现
         */
        public static int getSum3(int...a){
        System.out.printIn(a.length);
        renturn1;
        }
        public static int getSum4(int...a){
            int sum = 0 ;
            for(int i : a){
                sum = sum + i;
            }
            return sum;
        }




     }

（2）可变参数的注意事项

   /*
        * 可变参数的注意事项
        * 1. 一个方法中,可变参数只能有一个
        * 2. 可变参数,必须写在参数列表的最后一位
        */
        //错误写法：
         public static void function(int...a,String...b){
         }
          public static void function(int...a,int b, int c){
         }
         //正确写法：
         public static void function(int b, int c,int...a){
         }
         public static void function(Object...o){
         }

1.10 Collections集合工具类

Collections工具类
① Collections.shuffle方法：对List集合中的元素,进行随机排列
② Collections.binarySearch静态方法：对List集合进行二分搜索,方法参数,传递List集合,传递被查找的元素
③ Collections.sort静态方法：对于List集合,进行升序排列

      /*
       *  集合操作的工具类
       *    Collections
       */
      public class CollectionsDemo {
        public static void main(String[] args) {
            function_2();
        }
        /*
         * ①Collections.shuffle方法
         * 对List集合中的元素,进行随机排列
         */
        public static void function_2(){
            List<Integer> list = new ArrayList<Integer>();
            list.add(1);
            list.add(5);
            list.add(9);
            list.add(11);
            list.add(8);
            list.add(10);
            list.add(15);
            list.add(20);   
            System.out.println(list);
            //输出[1,5,9,11,8,15,20]

            //调用工具类方法shuffle对集合随机排列
            Collections.shuffle(list);
            System.out.println(list); 
            //输出[11,9,15,5,1,10,20,8]
            }

        /*
         * ②Collections.binarySearch静态方法
         * 对List集合进行二分搜索,方法参数,传递List集合,传递被查找的元素
         */
        public static void function_1(){
            List<Integer> list = new ArrayList<Integer>();
            list.add(1);
            list.add(5);
            list.add(8);
            list.add(10);
            list.add(15);
            list.add(20);
            //调用工具类静态方法binarySearch
            int index = Collections.binarySearch(list, 15);
            System.out.println(index); 
            //输出：4
            int index = Collections.binarySearch(list, 16);
            System.out.println(index); 
            //输出：-6  返回负的插入点减一
        }

        /*
         *  ③Collections.sort静态方法
         *  对于List集合,进行升序排列
         */
        public static void function(){
            //创建List集合
            List<String> list = new ArrayList<String>();
            list.add("ewrew");
            list.add("qwesd");
            list.add("Qwesd");
            list.add("bv");
            list.add("wer");
            System.out.println(list);
            //输出：[ewrew,qwesd,Qwesd,bv,wer]
            //调用集合工具类的方法sort
            Collections.sort(list);
            System.out.println(list);
            输出：[Qwesd,bv,ewrew,qwesd,wer]
        }
      }

1.11 集合嵌套

（1）集合的嵌套

集合嵌套并不是一个新的知识点，仅仅是集合内容又是集合，如Collection集合嵌套、Collection集合与Map集合相互嵌套、Map集合嵌套。
- ArrayList嵌套 ArrayList：
- Map嵌套 ArrayList：
- Map集合嵌套：

   /*
     *  Map集合的嵌套,Map中存储的还是Map集合
     *  要求:
     *    传智播客  
     *      Java基础班
     *        001  张三
     *        002  李四
     *      
     *      Java就业班
     *        001  王五
     *        002  赵六
     *  对以上数据进行对象的存储
     *   001---张三 可以看成 键值对
     *   Java基础班: 存储学号和姓名的键值对
     *   Java就业班: 同上
     *   传智播客: 存储的是班级
     *   
     *   基础班Map   <学号,姓名>
     *   传智播客Map  <班级名字, 基础班Map>
     */
    public class MapMapDemo {
        public static void main(String[] args) {
            //定义基础班集合
            HashMap<String, String> javase = new HashMap<String, String>();
            //定义就业班集合
            HashMap<String, String> javaee = new HashMap<String, String>();
            //向班级集合中,存储学生信息
            javase.put("001", "张三");
            javase.put("002", "李四");

            javaee.put("001", "王五");
            javaee.put("002", "赵六");
            //定义传智播客集合容器,键是班级名字,值是两个班级容器
            HashMap<String, HashMap<String,String>> czbk =
                    new HashMap<String, HashMap<String,String>>();
            czbk.put("基础班", javase);
            czbk.put("就业班", javaee);

             keySet(czbk);//下一小节内容

        }

（2）集合的嵌套keySet遍历

       /*
        *  Map集合的嵌套,Map中存储的还是Map集合
        *  要求:
        *    传智播客  
        *      Java基础班
        *        001  张三
        *        002  李四
        *      
        *      Java就业班
        *        001  王五
        *        002  赵六
        *  对以上数据进行对象的存储
        *   001 张三  键值对
        *   Java基础班: 存储学号和姓名的键值对
        *   Java就业班:
        *   传智播客: 存储的是班级
        *   
        *   基础班Map   <学号,姓名>
        *   传智播客Map  <班级名字, 基础班Map>
        */
       public class MapMapDemo {
        public static void main(String[] args) {
            //定义基础班集合
            HashMap<String, String> javase = new HashMap<String, String>();
            //定义就业班集合
            HashMap<String, String> javaee = new HashMap<String, String>();
            //向班级集合中,存储学生信息
            javase.put("001", "张三");
            javase.put("002", "李四");

            javaee.put("001", "王五");
            javaee.put("002", "赵六");
            //定义传智播客集合容器,键是班级名字,值是两个班级容器
            HashMap<String, HashMap<String,String>> czbk =
                    new HashMap<String, HashMap<String,String>>();
            czbk.put("基础班", javase);
            czbk.put("就业班", javaee);

             keySet(czbk);

        }



        public static void keySet(HashMap<String,HashMap<String,String>> czbk){
            //调用czbk集合方法keySet将键存储到Set集合
            Set<String> classNameSet = czbk.keySet();
            //迭代Set集合
            Iterator<String> classNameIt = classNameSet.iterator();
            while(classNameIt.hasNext()){
                //classNameIt.next获取出来的是Set集合元素,czbk集合的键
                String classNameKey = classNameIt.next();
                //czbk集合的方法get获取值,值是一个HashMap集合
                HashMap<String,String> classMap = czbk.get(classNameKey);
                //调用classMap集合方法keySet,键存储到Set集合
                Set<String> studentNum = classMap.keySet();
                Iterator<String> studentIt = studentNum.iterator();

                   while(studentIt.hasNext()){
                    //studentIt.next获取出来的是classMap的键,学号
                    String numKey = studentIt.next();
                    //调用classMap集合中的get方法获取值
                    String nameValue = classMap.get(numKey);
                    System.out.println(classNameKey+".."+numKey+".."+nameValue);
                    //输出结果：就业班..001..王五
                    //        就业班..002..赵六
                    //        基础班..001..张三
                    //        基础班..002..李四
                }
            }

            System.out.println("==================================");
            for(String className: czbk.keySet()){
               HashMap<String, String> hashMap = czbk.get(className);   
               for(String numKey : hashMap.keySet()){
                   String nameValue = hashMap.get(numKey);
                   System.out.println(className+".."+numKey+".."+nameValue);
               }
            }
        }

       }

（3）集合的嵌套entrySet遍历

  /*
     *  Map集合的嵌套,Map中存储的还是Map集合
     *  要求:
     *    传智播客  
     *      Java基础班
     *        001  张三
     *        002  李四
     *      
     *      Java就业班
     *        001  王五
     *        002  赵六
     *  对以上数据进行对象的存储
     *   001 张三  键值对
     *   Java基础班: 存储学号和姓名的键值对
     *   Java就业班:
     *   传智播客: 存储的是班级
     *   
     *   基础班Map   <学号,姓名>
     *   传智播客Map  <班级名字, 基础班Map>
     */
    public class MapMapDemo {
        public static void main(String[] args) {
            //定义基础班集合
            HashMap<String, String> javase = new HashMap<String, String>();
            //定义就业班集合
            HashMap<String, String> javaee = new HashMap<String, String>();
            //向班级集合中,存储学生信息
            javase.put("001", "张三");
            javase.put("002", "李四");

            javaee.put("001", "王五");
            javaee.put("002", "赵六");
            //定义传智播客集合容器,键是班级名字,值是两个班级容器
            HashMap<String, HashMap<String,String>> czbk =
                    new HashMap<String, HashMap<String,String>>();
            czbk.put("基础班", javase);
            czbk.put("就业班", javaee);

            entrySet(czbk);
        }

        public static void entrySet(HashMap<String,HashMap<String,String>> czbk){
            //调用czbk集合方法entrySet方法,将czbk集合的键值对关系对象,存储到Set集合
            Set<Map.Entry<String, HashMap<String,String>>> 
                                     classNameSet = czbk.entrySet();
            //迭代器迭代Set集合
            Iterator<Map.Entry<String, HashMap<String,String>>> classNameIt = classNameSet.iterator();
            while(classNameIt.hasNext()){
                //classNameIt.next方法,取出的是czbk集合的键值对关系对象
                Map.Entry<String, HashMap<String,String>> classNameEntry =  classNameIt.next();
                //classNameEntry方法 getKey,getValue
                String classNameKey = classNameEntry.getKey();
                //获取值,值是一个Map集合
                HashMap<String,String> classMap = classNameEntry.getValue();
                //调用班级集合classMap方法entrySet,键值对关系对象存储Set集合
                Set<Map.Entry<String, String>> studentSet = classMap.entrySet();
                //迭代Set集合
                Iterator<Map.Entry<String, String>> studentIt = studentSet.iterator();
                while(studentIt.hasNext()){
                    //studentIt方法next获取出的是班级集合的键值对关系对象
                    Map.Entry<String, String> studentEntry = studentIt.next();
                    //studentEntry方法 getKey getValue
                    String numKey = studentEntry.getKey();
                    String nameValue = studentEntry.getValue();
                    System.out.println(classNameKey+".."+numKey+".."+nameValue);
                    //输出结果：就业班..001..王五
                    //        就业班..002..赵六
                    //        基础班..001..张三
                    //        基础班..002..李四
                }
            }
             System.out.println("==================================");

            for (Map.Entry<String, HashMap<String, String>> me : czbk.entrySet()) {
                String classNameKey = me.getKey();
                HashMap<String, String> numNameMapValue = me.getValue();
                for (Map.Entry<String, String> nameMapEntry : numNameMapValue.entrySet()) {
                    String numKey = nameMapEntry.getKey();
                    String nameValue = nameMapEntry.getValue();
                    System.out.println(classNameKey + ".." + numKey + ".." + nameValue);
                }
            }
        }


    }

1.12 集合继承体系的面向对象思想

这里写图片描述

接口：用来明确所有集合中该具有的功能，相当于在定义集合功能标准；
抽象类：把多个集合中功能实现方式相同的方法，抽取到抽象类实现，具体集合不再遍写，继承使用即可；
具体类：继承抽象类，实现接口，重写所有抽象方法，达到具备指定功能的集合。每个具体集合类，根据自身的数据存储结构方式，对接口中的功能方法，进行不同方式的实现。

第2章模拟斗地主洗牌发牌

2.1 案例介绍

按照斗地主的规则，完成洗牌发牌的动作。
这里写图片描述
具体规则：
1. 组装54张扑克牌
2. 将54张牌顺序打乱
3. 三个玩家参与游戏，三人交替摸牌，每人17张牌，最后三张留作底牌。
4. 查看三人各自手中的牌（按照牌的大小排序）、底牌

手中扑克牌从大到小的摆放顺序：大王,小王,2,A,K,Q,J,10,9,8,7,6,5,4,3

2.2 案例需求分析

（1）准备牌：
完成数字与纸牌的映射关系：
使用双列Map(HashMap)集合，完成一个数字与字符串纸牌的对应关系(相当于一个字典)。
这里写图片描述
（2）洗牌：
通过数字完成洗牌发牌

（3）发牌：

存放的过程中要求数字大小与斗地主规则的大小对应。
将代表不同纸牌的数字分配给不同的玩家与底牌。
这里写图片描述
将每个人以及底牌设计为ArrayList,将最后3张牌直接存放于底牌，剩余牌通过对3取模依次发牌。
（4）看牌：
通过Map集合找到对应字符展示。
通过查询纸牌与数字的对应关系，由数字转成纸牌字符串再进行展示。

2.3 实现代码步骤

（1）斗地主的准备牌

这里写图片描述

     /*
      *  实现模拟斗地主的功能
      *   1. 组合牌
      *   2. 洗牌
      *   3. 发牌
      *   4. 看牌
      */
     public class DouDiZhu {
        public static void main(String[] args) {
            //1. 组合牌
            //创建Map集合,键是编号,值是牌
            HashMap<Integer,String> pooker = new HashMap<Integer, String>();
            //创建List集合,存储编号
            ArrayList<Integer> pookerNumber = new ArrayList<Integer>();
            //定义出13个点数的数组（大小王先空过去）
            String[] numbers = {"2","A","K","Q","J","10","9","8","7","6","5","4","3"};
            //定义4个花色数组
            String[] colors = {"♠","♥","♣","♦"};
            //大小王索引为0和1 先空过去，从2开始定义整数变量,作为键出现
            int index = 2;
            //遍历数组,花色+点数的组合,存储到Map集合
            for(String number : numbers){
                for(String color : colors){
                    pooker.put(index, color+number);
                    pookerNumber.add(index);
                    index++;
                }
            }
            System.out.println(pooker);
            //输出：{2=♠2, 3=♥2, 4=♣2, 5=♦2, 6=♠A, 7=♥A, 8=♣A, 9=♦A, 10=♠K, 11=♥K, 12=♣K, 13=♦K, 14=♠Q, 15=♥Q, 16=♣Q, 17=♦Q, 18=♠J, 19=♥J, 20=♣J, 21=♦J, 22=♠10, 23=♥10, 24=♣10, 25=♦10, 26=♠9, 27=♥9, 28=♣9, 29=♦9, 30=♠8, 31=♥8, 32=♣8, 33=♦8, 34=♠7, 35=♥7, 36=♣7, 37=♦7, 38=♠6, 39=♥6, 40=♣6, 41=♦6, 42=♠5, 43=♥5, 44=♣5, 45=♦5, 46=♠4, 47=♥4, 48=♣4, 49=♦4, 50=♠3, 51=♥3, 52=♣3, 53=♦3}

            //存储大王,和小王,索引是从0~54,对应大王,小王,...3(牌的顺序从大到小)
            pooker.put(0, "大王");
            pookerNumber.add(0);
            pooker.put(1, "小王");
            pookerNumber.add(1);

     }

（2）斗地主的洗牌

    /*
       *  实现模拟斗地主的功能
       *   1. 组合牌
       *   2. 洗牌
       *   3. 发牌
       *   4. 看牌
       */
      public class DouDiZhu {
        public static void main(String[] args) {
            //1. 组合牌
            //创建Map集合,键是编号,值是牌
            HashMap<Integer,String> pooker = new HashMap<Integer, String>();
            //创建List集合,存储编号
            ArrayList<Integer> pookerNumber = new ArrayList<Integer>();
            //定义出13个点数的数组
            String[] numbers = {"2","A","K","Q","J","10","9","8","7","6","5","4","3"};
            //定义4个花色数组
            String[] colors = {"♠","♥","♣","♦"};
            //定义整数变量,作为键出现
            int index = 2;
            //遍历数组,花色+点数的组合,存储到Map集合
            for(String number : numbers){
                for(String color : colors){
                    pooker.put(index, color+number);
                    pookerNumber.add(index);
                    index++;
                }
            }
            //存储大王,和小王
            pooker.put(0, "大王");
            pookerNumber.add(0);
            pooker.put(1, "小王");
            pookerNumber.add(1);

            //洗牌,将牌的编号打乱
            Collections.shuffle(pookerNumber);


        }

      }

（3）斗地主的发牌

  /*
     *  实现模拟斗地主的功能
     *   1. 组合牌
     *   2. 洗牌
     *   3. 发牌
     *   4. 看牌
     */
    public class DouDiZhu {
        public static void main(String[] args) {
            //1. 组合牌
            //创建Map集合,键是编号,值是牌
            HashMap<Integer,String> pooker = new HashMap<Integer, String>();
            //创建List集合,存储编号
            ArrayList<Integer> pookerNumber = new ArrayList<Integer>();
            //定义出13个点数的数组
            String[] numbers = {"2","A","K","Q","J","10","9","8","7","6","5","4","3"};
            //定义4个花色数组
            String[] colors = {"♠","♥","♣","♦"};
            //定义整数变量,作为键出现
            int index = 2;
            //遍历数组,花色+点数的组合,存储到Map集合
            for(String number : numbers){
                for(String color : colors){
                    pooker.put(index, color+number);
                    pookerNumber.add(index);
                    index++;
                }
            }
            //存储大王,和小王
            pooker.put(0, "大王");
            pookerNumber.add(0);
            pooker.put(1, "小王");
            pookerNumber.add(1);

            //洗牌,将牌的编号打乱
            Collections.shuffle(pookerNumber);

            //发牌功能,将牌编号,发给玩家集合,底牌集合
            ArrayList<Integer> player1 = new ArrayList<Integer>();
            ArrayList<Integer> player2 = new ArrayList<Integer>();
            ArrayList<Integer> player3 = new ArrayList<Integer>();
            ArrayList<Integer> bottom = new ArrayList<Integer>();

            //发牌采用的是集合索引%3，结果只能是123，分别发给三个玩家
            for(int i = 0 ; i < pookerNumber.size() ; i++){
                //必须先将底牌做好，因为%3之后不会有剩下的牌了
                if(i < 3){
                    //存到底牌去
                    bottom.add( pookerNumber.get(i));
                   //对索引%3判断
                }else if(i % 3 == 0){
                    //索引上的编号,发给玩家1
                    player1.add( pookerNumber.get(i) );
                }else if( i % 3 == 1){
                    //索引上的编号,发给玩家2
                    player2.add( pookerNumber.get(i) );
                }else if( i % 3 == 2){
                    //索引上的编号,发给玩家3
                    player3.add( pookerNumber.get(i) );
                }
            }

        }

    }

（4）斗地主的看牌

  /*
      *  实现模拟斗地主的功能
      *   1. 组合牌
      *   2. 洗牌
      *   3. 发牌
      *   4. 看牌
      */
     public class DouDiZhu {
        public static void main(String[] args) {
            //1. 组合牌
            //创建Map集合,键是编号,值是牌
            HashMap<Integer,String> pooker = new HashMap<Integer, String>();
            //创建List集合,存储编号
            ArrayList<Integer> pookerNumber = new ArrayList<Integer>();
            //定义出13个点数的数组
            String[] numbers = {"2","A","K","Q","J","10","9","8","7","6","5","4","3"};
            //定义4个花色数组
            String[] colors = {"♠","♥","♣","♦"};
            //定义整数变量,作为键出现
            int index = 2;
            //遍历数组,花色+点数的组合,存储到Map集合
            for(String number : numbers){
                for(String color : colors){
                    pooker.put(index, color+number);
                    pookerNumber.add(index);
                    index++;
                }
            }
            //存储大王,和小王
            pooker.put(0, "大王");
            pookerNumber.add(0);
            pooker.put(1, "小王");
            pookerNumber.add(1);

            //洗牌,将牌的编号打乱
            Collections.shuffle(pookerNumber);

            //发牌功能,将牌编号,发给玩家集合,底牌集合
            ArrayList<Integer> player1 = new ArrayList<Integer>();
            ArrayList<Integer> player2 = new ArrayList<Integer>();
            ArrayList<Integer> player3 = new ArrayList<Integer>();
            ArrayList<Integer> bottom = new ArrayList<Integer>();

            //发牌采用的是集合索引%3
            for(int i = 0 ; i < pookerNumber.size() ; i++){
                //先将底牌做好
                if(i < 3){
                    //存到底牌去
                    bottom.add( pookerNumber.get(i));
                   //对索引%3判断
                }else if(i % 3 == 0){
                    //索引上的编号,发给玩家1
                    player1.add( pookerNumber.get(i) );
                }else if( i % 3 == 1){
                    //索引上的编号,发给玩家2
                    player2.add( pookerNumber.get(i) );
                }else if( i % 3 == 2){
                    //索引上的编号,发给玩家3
                    player3.add( pookerNumber.get(i) );
                }
            }
            //对玩家手中的编号排序
            Collections.sort(player1);
            Collections.sort(player2);
            Collections.sort(player3);
            //看牌,将玩家手中的编号,到Map集合中查找,根据键找值
            //定义方法实现
            look("刘德华",player1,pooker);
            look("张曼玉",player2,pooker);
            look("林青霞",player3,pooker);
            look("底牌",bottom,pooker);
        }
        public static void look(String name,ArrayList<Integer> player,HashMap<Integer,String> pooker){
            //遍历ArrayList集合,获取元素,作为键,到集合Map中找值
            System.out.print(name+" ");
            for(Integer key : player){
                String value = pooker.get(key);
                System.out.print(value+" ");
            }
            System.out.println();//每个玩家换个行
        }
     }  
             //输出结果：刘德华 ♠A ♥A ♣A ♦A ♠K ♦K ♠Q ♥Q ♦9 ♥8 ♥7 ♣7 ♣5 ♦5 ♠3 ♥3 ♣3 
             //        张曼玉 小王 ♠2 ♣2 ♥K ♣Q ♣J ♠10 ♣10 ♦10 ♣9 ♣8 ♠7 ♠5 ♥5 ♣4 ♦4 ♦3 
             //        林青霞 大王 ♥2 ♦2 ♣K ♦Q ♠J ♥J ♥10 ♥9 ♦8 ♦7 ♠6 ♥6 ♣6 ♦6 ♠4 ♥4 
             //        底牌 ♦J ♠8 ♠9

第3章总结

（1）Map集合:

map集合中的元素都是成对出现，成对存储的
map集合中的元素都是以一对键和值的形式组成存在的，称为键值对，理解为夫妻对
map集合中的键不能重复存储，值可以重复
map集合中的每一个键对应着一个值
（2）方法：
V put(K key, V value) 把指定的键与指定的值添加到Map集合中
V remove(Object key) 把指定的键所对应的键值对元素在Map集合中删除，返回被删除元素的值
Set《Map.Entry《K,V》》 entrySet() 获取到Map集合中所有的键值对对象的集合(Set集合)
V get(Object key) 根据指定的键，在Map集合中获取对应的值
Set《K》 keySet() 获取Map集合中所有的键，存储到Set集合中

（3） Map集合遍历的两种方式

方式1：根据键找值的方式
//a, 获取到Map集合中所有的键，返回对应的Set集合
//b, 遍历键的集合，获取到每一个键
//c, 通过键，找到对应的值

//获取到Map集合中所有的键，返回对应的Set集合
Set《String》keys = map.keySet();
//遍历键的集合，获取到每一个键
for (String key : keys) {
    //通过键，找到对应的值
    Student s = map.get(key);
    System.out.println( key + "..." + s.getName() + "..." + s.getAge() );
}

方式2：根据键值对对象找键和值的方式
//a, 获取Map集合中所有的键值对元素,返回对应的Set集合
//b, 遍历键值对元素集合，获取到每一个键值对元素对象
//c, 通过键值对元素对象，获取对应的键，和对应的值

//获取Map集合中所有的键值对元素,返回对应的Set集合
Set《 Map.Entry《String, Student》》entrySet = map.entrySet();
//遍历键值对元素集合，获取到每一个键值对元素对象
for (Map.Entry《String, Student》 entry : entrySet) {
    //通过键值对元素对象，获取对应的键，和对应的值
    //找键
    String key = entry.getKey();
    //找值
    Student s = entry.getValue();
    //打印
    System.out.println( key+"..."+s.getName()+"..."+s.getAge() );
}

（4） HashMap:

特点：
是Map集合的子集合
底层采用哈希表结构
HashMap集合中的key不能重复，通过重写hashCode() 与 equals()方法来保证键的唯一。
不能保证元素存与取的顺序完全一致
（5）LinkedHashMap:
特点：
是HashMap集合的子集合
底层采用哈希表+链表结构
LinkedHashMap集合中的key不能重复，通过重写hashCode() 与 equals()方法来保证键的唯一。

（6）Collections中的方法：
public static 《T》 void sort(List《T》list) 排序
public static void shuffle(List《?》 list) 集合中的元素存储位置随机打乱

娇小妖

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JAVA SE — Day 20

目录第1章 Map接口 1.1 概述 1.2 常用集合概述1.3 常用方法 1.4 遍历键找值方式1.5 Entry键值对对象1.6 Map集合遍历键值对方式1.7 HashMap存储自定义类型键值 1.8 静态导入1.9 可变参数 1.10 Collections集合工具类1.11 集合嵌套1.12 集合继承体系的面向对象思想第2章模拟斗地主洗牌发牌第3章总结
复制链接

扫一扫