[Java学习日记]可变参数、集合帮助类、集合嵌套、斗地主准、洗、发、看牌

目录

一.可变参数:JDK5提出，底层就是数组

二.集合工具类Collections

三.案例：随机生成学生名字，不重复，全部随机完再次随机

四.集合嵌套

五.斗地主准、洗、发、看牌

---

一.可变参数:JDK5提出，底层就是数组

1.方法中设置可变参数的书写格式？
2.一个方法中能设置多个可变参数吗？
3.可变参数需要设置在方法参数中的的哪个位置呢？

public class Demo251 {
    public static void main(String[] args) {
        getSum(0, 1, 2, 3, 4, 5, 6, 7);
    }
    private static void getSum(int a, int... arr) {
        System.out.println("1.格式：数据类型...数据名称");
        System.out.println("2.方法底层中只能写一个可变参数（因为能把很多参数都传递进去）");
        System.out.println("3.需要把可便参数写在方法形参定义的最后,比如上面的a和arr是不能交换的");
        int sum = a;
        for (int i : arr)  sum += i;
        System.out.println(sum);
    }
}

---

二.集合工具类Collections

1.批量添加元素使用什么方法？
2.打乱集合顺序使用什么方法？
3.排序集合是用什么方法？
4.查找元素使用什么方法？
5.拷贝集合到另一个集合使用什么方法？
6.求最大最小值使用什么方法？
7.交换集合中的元素使用什么方法？
8.填充集合使用什么方法？

public class Demo252 {
    public static void main(String[] args) {
        ArrayList<Integer> arrayList = new ArrayList<>();
        HashSet<Integer>  hashSet = new HashSet<>();

        System.out.println("1.使用addAll方法批量添加元素");
        Collections.addAll(hashSet,1,2,3,4,5);
        Collections.addAll(arrayList,1,2,3,4,5);

        System.out.println("2.使用shuffle方法打乱集合中元素的顺序");
        Collections.shuffle(arrayList);
        System.out.println(arrayList);

        System.out.println("3.使用sort方法，排序的写法和Array一样，可以传递单个参数，也能够多传递一个比较规则Comparator");
        Collections.sort(arrayList, (o1,o2) ->o1-o2);
        System.out.println(arrayList);

        System.out.println("4.使用binarySearch方法，二分查找查找元素");
        System.out.println(Collections.binarySearch(arrayList, 3));

        System.out.println("5.使用copy方法，拷贝元素,注意拷贝目标长度>=源长度");
        Collections.copy(arrayList,arrayList);

        System.out.println("6.使用max||min方法，求最大(小)值");
        System.out.println(Collections.max(hashSet));

        System.out.println("7.使用swap方法，交换集合中的元素");
        Collections.swap(arrayList,0,1);
        System.out.println(arrayList);

        System.out.println("8.使用fill方法，填充集合");
        Collections.fill(arrayList,8);
        System.out.println(arrayList);
    }
}

---

三.案例：随机生成学生名字，不重复，全部随机完再次随机

1.arrayList的remove方法返回值是什么？
2.如何交换两个arraylist内（其中一个arrayList为空）的元素？

public class Demo253 {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();
        ArrayList<String> arrayList2 = new ArrayList<>();
        Collections.addAll(arrayList,"zhangsan","lisi","wangwu","zhaoliu","qianqi","fengba","sunjiu");
        do{
            Collections.shuffle(arrayList);
            int index = arrayList.size()-1;
            //1.代码简化：remove返回被删除索引
            String str = arrayList.remove(index);
            arrayList2.add(str);
            System.out.println(str);
            System.out.println(arrayList+""+arrayList2);
            if (index == 0){
                System.out.println("集合A（无元素）B（有元素）互换，先把A用B填满，再清空B即可");
                arrayList.addAll(arrayList2);
                arrayList2.clear();
            }
        }while (new Scanner(System.in).nextLine().equals(""));
    }
}

---

四.集合嵌套

需求：定义集合，键用Province表示，值有多个,表示市
如何定义集合嵌套？

public class Demo254 {
    public static void main(String[] args) {
        System.out.println("在Map中定义值为List或者Set");
        HashMap<String, ArrayList<String>> hashMap = new HashMap<>();
        ArrayList<String> arrayList1 = new ArrayList<>();
        ArrayList<String> arrayList2 = new ArrayList<>();
        ArrayList<String> arrayList3 = new ArrayList<>();
        Collections.addAll(arrayList1, "长沙市", "益阳市", "娄底市");
        Collections.addAll(arrayList2, "广州市", "深圳市");
        Collections.addAll(arrayList3, "福州市", "厦门市");
        hashMap.put("湖南省", arrayList1);
        hashMap.put("广东省", arrayList2);
        hashMap.put("福建省", arrayList3);
        for (Map.Entry<String, ArrayList<String>> entry : hashMap.entrySet()) {
            System.out.print(entry.getKey() + " = ");
            StringJoiner sj = new StringJoiner(", ");
            for (int i = 0; i < entry.getValue().size(); i++) sj.add(entry.getValue().get(i));
            System.out.println(sj);
        }
    }
}

 

---

五.斗地主准、洗、发、看牌

1.创建App与PokerGame，在PokerGame完场准备牌，洗牌，发牌，看牌操作

2.准备牌：初始化变量写在静态代码块里面，调用牌的变量写在成员变量，并用静态修饰

3.洗牌调用集合帮助类的方法即可，发牌定义四个集合存储三个人的初始拍以及地主的额外三张牌

4.在发牌的过程中可以采用除以三取余的方法对三个人发牌
虽然说相比于按照下标分块发牌，但是这种除余分不同情况思想需要学会

5.新增看牌方法LookPoker，给每位玩家看牌

6.给牌排序，在这里新建第二个PokerGame，重写程序结构：
使用hashMap存储牌的序号与牌，使用arraylist存储牌的序号，使用treeSet给牌排序

7.新建第三个PokerGame，给牌排序
使用hashmap存储牌的牌面与其价值，使用arraylist存储牌面，使用arraylist的sort方法排序

8.灵活使用布尔类型的变量取反！

public class App {
    public static void main(String[] args) {
        new PokerGame3();
    }
}

public class PokerGame1 {
    final static ArrayList<String> arrayList = new ArrayList<>();

    //准备：54张牌，这里使用静态代码块：随着类加载，只执行一次，可以不用一个一个写static修饰的代码了
    //但是这个类的方法不能访问静态代码块中的变量
    static {
        //在准备牌的时候，不用一张一张加，可以先把最基础的属性分开（花色与数字）
        String[] color = {"♣", "♥", "♠", "♦"};
        String[] number = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"};
        for (String n : number) {
            for (String c : color) {
                arrayList.add(n + c);
            }
        }
        arrayList.add("小王");
        arrayList.add("大王");
    }

    public PokerGame1() {

        //洗牌:使用集合帮助类的方法即可
        Collections.shuffle(arrayList);

        //发牌：一个底牌，三个玩家
        ArrayList<String> lord = new ArrayList<>();
        ArrayList<String> player1 = new ArrayList<>();
        ArrayList<String> player2 = new ArrayList<>();
        ArrayList<String> player3 = new ArrayList<>();
        for (int i = 0; i < 3; i++) lord.add(arrayList.get(i));
        for (int i = 3; i < 54; i++) {
            //这种有确定的情况数量就可以使用switch
            switch (i % 3) {
                case 0 -> player1.add(arrayList.get(i));
                case 1 -> player2.add(arrayList.get(i));
                case 2 -> player3.add(arrayList.get(i));
            }
        }

        //排序：这里是用键代表序号，用值代表牌，这样的画排序就直接按照键来排就可以了
        //真正需要的是序号，就像拼图游戏一样，真正要操作的是坐标，而不是图片,在Game2里面排序

        //看牌
        lookPoker("地主牌", lord);
        lookPoker("玩家一", player1);
        lookPoker("玩家二", player2);
        lookPoker("玩家三", player3);

    }

    public void lookPoker(String name, ArrayList<String> arrayList) {
        System.out.print(name + "：");
        for (String s : arrayList) {
            System.out.print("  \t" + s);
        }
        System.out.println();
    }
}

两种排序方式：

//第一种排序方式：利用序号进行排序
public class PokerGame2 {
    final static ArrayList<Integer> poker = new ArrayList<>();
    //只需要产生对应关系即可，不需要排序Treemap
    final static HashMap<Integer, String> hashMap = new HashMap<>();

    static {
        for (int i = 0; i < 54; i++) poker.add(i);
        String[] number = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"};
        String[] color = {"♣", "♠", "♥", "♦"};
        for (int i = 0; i < number.length; i++) {
            for (int j = 0; j < color.length; j++)
                hashMap.put(i * color.length + j, number[i] + color[j]);
        }
        hashMap.put(52, "小王");
        hashMap.put(53, "大王");
    }

    public PokerGame2() {
        Collections.shuffle(poker);
        //使用TreeSet加入元素，自动排序
        TreeSet<Integer> lord = new TreeSet<>();
        TreeSet<Integer> player1 = new TreeSet<>();
        TreeSet<Integer> player2 = new TreeSet<>();
        TreeSet<Integer> player3 = new TreeSet<>();
        for (int i = 0; i < 3; i++) lord.add(poker.get(i));
        for (int i = 3; i < 54; i++) {
            switch (i % 3) {
                case 0 -> player1.add(poker.get(i));
                case 1 -> player2.add(poker.get(i));
                case 2 -> player3.add(poker.get(i));
            }
        }
        showPoker(lord);
        showPoker(player1);
        showPoker(player2);
        showPoker(player3);
    }

    private void showPoker(TreeSet<Integer> tree) {
        for (Integer integer : tree)
            System.out.print(hashMap.get(integer) + "\t");
        System.out.println();
    }
}

//第二种排序方式：利用牌的价值进行排序
public class PokerGame3 {
    final static ArrayList<String> arrayList = new ArrayList<>();
    final static HashMap<String, Integer> hashmap = new HashMap<>();

    static {
        String[] color = {"♣", "♥", "♠", "♦"};
        String[] number = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"};
        for (String n : number) {
            for (String c : color) {
                arrayList.add(n + c);
            }
        }
        arrayList.add("小王");
        arrayList.add("大王");
        //放入Map集合 如果map中有就查询价值，没有使用数字
        hashmap.put("J", 11);
        hashmap.put("Q", 12);
        hashmap.put("K", 13);
        hashmap.put("A", 14);
        hashmap.put("2", 15);
        hashmap.put("小", 20);
        hashmap.put("大", 30);
    }

    public PokerGame3() {
        Collections.shuffle(arrayList);
        ArrayList<String> lord = new ArrayList<>();
        ArrayList<String> player1 = new ArrayList<>();
        ArrayList<String> player2 = new ArrayList<>();
        ArrayList<String> player3 = new ArrayList<>();
        for (int i = 0; i < 3; i++) lord.add(arrayList.get(i));
        for (int i = 3; i < 54; i++) {
            switch (i % 3) {
                case 0 -> player1.add(arrayList.get(i));
                case 1 -> player2.add(arrayList.get(i));
                case 2 -> player3.add(arrayList.get(i));
            }
        }

        lord.sort(Comparator.comparingInt(this::trans));
        player1.sort(Comparator.comparingInt(this::trans));
        player2.sort(Comparator.comparingInt(this::trans));
        player3.sort(Comparator.comparingInt(this::trans));

        lookPoker("地主牌", lord);
        lookPoker("玩家一", player1);
        lookPoker("玩家二", player2);
        lookPoker("玩家三", player3);
    }

    public void lookPoker(String name, ArrayList<String> arrayList) {
        System.out.print(name + "：");
        for (String s : arrayList) System.out.print("\t" + s);
        System.out.println();
    }

    public Integer trans(String str) {
        String n = str.substring(0, str.length() - 1);
        if (hashmap.containsKey(n)) return hashmap.get(n);
        else return Integer.parseInt(n);
    }
}