Java学习之随堂笔记系列——day16

1 可变参数
    概念：方法参数列表中的参数个数不确定，就表示可变参数。
    可变参数的本质：数组。
    注意事项：方法的参数列表中只能有一个可变参数，并且可变参数只能在参数列表的末尾。
    语法格式:(数据类型...变量名)   

 public class ParameterDemo {
        public static void main(String[] args) {
            add(10,20,30,40); //允许

            int[] arr={10,20,30,40};
            add(arr);//允许

            Integer[] arr2={10,20,30,40};
            //add(arr2); //报错，int[]和Integer[]不能相互转换
        }
        public static int add(int... nums){
            int sum=0;
            for (int num : nums) {
                sum+=num;
            }
            return sum;
        }
    }

    可变参数的使用；
        /*
            集合和数组之间的相互转换
                数组--->集合 Arrays
                    static <T> List<T>    asList​(T... a)    :返回由指定数组支持的固定大小的列表。
                集合--->数组 Collection
                    Object[]    toArray​()    :返回一个包含此集合中所有元素的数组。
                    <T> T[]    toArray​(T[] a)    :返回一个包含此集合中所有元素的数组; 返回的数组的运行时类型是指定数组的运行时类型。
         */
       

 public class ArgsDemo2 {
            public static void main(String[] args) {
                //数组--->集合
                Integer[] arr={10,20,30,40,50};
                List<Integer> list = Arrays.asList(arr);
                System.out.println(list);

                //集合--->数组
                List<String> lts=List.of("hello","world","java");
                //方式1：Object[]     toArray​()    :返回一个包含此集合中所有元素的数组
                Object[] arrs1 = lts.toArray();
                System.out.println(Arrays.toString(arrs1));

                //方式2： <T> T[]    toArray​(T[] a) ：需要传递一个数组对象，集合中数据是什么类型就创建一个该类型的空数组传进去
                /*String[] arrs2=new String[lts.size()];
                lts.toArray(arrs2);*/
                //简化写法
                String[] arrs2 = lts.toArray(new String[lts.size()]);
                System.out.println(Arrays.toString(arrs2));
            }
        }

2 Map集合
    map集合是一个双列集合，每次存储一对值，分为key-value。
    特点：key相同，value会被替换。也就是说key是唯一的。

    map集合的使用，常用方法：（重点）
        增/添加/改
            V put​(K key, V value):添加获取替换值，如果添加的key不存在，那么返回值就是null。如果key存在，那么新的value会替换原来的value值，返回值是被替换的值。
        删/移除
            V remove(K key):根据key移除一对元素。返回值就是对应的value值
        查/获取
            V get(K key):根据key获取value。
            K keySet()：获取所有的key
            Map.Entry<K,V> entrySet():获取所有的键值对对象
        遍历：（重要*****）
            方式1：键找值的方式，实现思路：
                1 获取所有的key
                2 遍历所有的key
                3 在遍历过程中根据key获取对应的value值，打印结果
            方式2：键值对的方式，实现思路：
                Map.Entry<K,V> : Entry是Map的一个内部接口（看成是内部类结构）。Entry也有泛型，泛型和Map集合的泛型一样。
                Entry的作用：在我们调用Map集合的put方法存值的时候，其实内部会创建一个Entry实现类对象，将我们存进去的值封装到Entry实现类对象中。
                            简单说：Map集合的内部会将每一对值封装成一个个Entry对象，Entry对象也叫做键值对对象。

                1 获取所有的键值对对象：Map.Entry<K,V> entrySet();
                2 遍历所有的键值对对象，获取每一个键值对对象
                3 调用键值对对象的getKey()和getValue()方法获取键和值，打印结果。
    Map集合key唯一的条件：
        key表示的对象要重写hashCode()和equals()方法。

3 Collections集合工具类
  1 Collection和Collections的区别？
    Collection是单列集合的顶层接口，Collections是操作集合的工具类。
  2 Collections的常用方法：
    static void    shuffle​(List<?> list)：随机打乱集合中元素的顺序。
    static <T extends Comparable<? super T>> void sort​(List<T> list)：
            对list集合中的元素进行自然排序，list集合中的元素必须要实现Comparable接口
    static <T> void    sort​(List<T> list, Comparator<? super T> c)：对list集合中的元素使用Comparator比较器进行排序

4 斗地主案例
    基础版思路分析
        1、准备牌：
            1、定义一个List集合作为牌盒
            2、定义两个数组，存储花色和牌号
            3、遍历数组，将花色和牌号进行组合，将组合好的牌存的牌盒list集合中
        2、洗牌：
            Collections.shuffle(牌盒集合)
        3、发牌
            1、定义三个List集合表示三个玩家和一个集合表示底牌
            2、遍历牌盒的list集合，共有54张牌在list集合中
            3、如果索引大于50，那么就发给底牌集合
            4、将索引对3取余，如果余数是0，那么就发给玩家1；如果余数是1，就发给玩家2；如果余数是2，就发给玩家3
            if(i>50){
               //发给底牌
            }else if(i%3==0){
              //发给玩家1
            }else if(I%3==1){
              //发给玩家2
            } else if(I%3==2){
              //发给玩家3
            }
        4、看牌：打印玩家姓名和玩家集合对象
    加强版思路分析：
        1、准备牌
            1、定一个Map集合最为牌盒
            2、定义两个数组，存储花色和牌号
            3、定义一个牌的序号起始值为0，每存一张牌，序号就++；
            4、遍历数组，将花色和牌号进行组合，将组合好的牌存的牌盒map集合中
        2、洗牌
            1.获取Map集合的所有key
               Set<Integer> keys=poker.keySet();
            2.将set集合转换成list，使用list的构造方法即可
            3.打乱顺序
               Collections.shuffle(list)
        3、发牌
            1、定义三个TreeSet集合表示三个玩家和一个集合表示底牌
            2、遍历装有序号的list集合，共有54个序号在list集合中
            3、如果索引大于50，那么就发给底牌集合
            4、将索引对3取余，如果余数是0，那么就发给玩家1；如果余数是1，就发给玩家2；如果余数是2，就发给玩家3
            if(i>50){
               //发给底牌
            }else if(i%3==0){
              //发给玩家1
            }else if(I%3==1){
              //发给玩家2
            } else if(I%3==2){
              //发给玩家3
            }
        4、看牌
            定义一个方法：遍历玩家的TreeSet集合，根据序号从Map集合中获取对应的牌，打印到控制台
作业1：查API文档实现数组和集合之间的相互转换