Collections的用法

java.util.Collections类，Collection 集合工具类，提供大量静态方法简化集合操作

一、常用方法

1、public static boolean addAll(Collection<? super T> c, T… elements)

将所有指定元素添加到指定 Collection 中，分别指定要添加的元素，或者将它们指定为一个数组

        ArrayList<Integer> list = new ArrayList<>();
		// Cannot resolve method 'addAll(ArrayList<Integer>, int[])'
		// int[] arr = {10, 20, 30};  // int类型 
        Integer[] arr = {10, 20, 30}; // Integer类型，集合元素类型只能是引用类型
        Collections.addAll(list, arr);
        Collections.addAll(list, 40, 50, 60);
        System.out.println(list); // [10, 20, 30, 40, 50, 60]

2、public static void shuffle(List<?> list) 打乱元素顺序，只针对 List 集合

 		List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        Collections.shuffle(list);
        System.out.println(list); // [4, 2, 5, 1, 3] 每次运行结果随机

3、public static void rotate(List<?> list, int distance) 根据指定的距离轮换指定列表中的元素

当方法的参数 distance 取正值时，向右移动 list 中的数据；取负值时，向左移动 list 中的数据

对于 0 和 list.size()-1 之间的所有 i 值，索引 i 处的元素将是以前位于索引 (i - distance) mod list.size() 处的元素

  		List<Integer> linkedList = new LinkedList<>();
        for (int i = 1; i <= 5; i++) {
            linkedList.add(i);
        }
        System.out.println("旋转前，链表中的数据");
        Iterator<Integer> it = linkedList.iterator();
        while (it.hasNext()) {
            System.out.printf("%d\t", it.next()); // 1	2	3	4	5
        }

        Collections.rotate(linkedList, 1);
        System.out.println("\n旋转后，链表中的数据");
        it = linkedList.iterator(); // 必须重新获取迭代器
        while (it.hasNext()) {
            System.out.printf("%d\t", it.next()); // 5	1	2	3	4	
        }

4、public static void reverse(List<?> list) 反转元素顺序，只针对 List 集合

 		List<Integer> list = Arrays.asList(1, 2, 59, 12, 87);
        Collections.reverse(list);
        System.out.println(list); // [87, 12, 59, 2, 1]

5、public static Comparator reverseOrder()

返回一个比较器，以逆自然顺序对实现 Comparable 接口的对象数组或集合进行排序

		// 数组，逆自然顺序
        String[] strs = {"c++", "java", "php"};
        Arrays.sort(strs, Collections.reverseOrder()); // 降序
        System.out.println(Arrays.toString(strs));     // [php, java, c++]

		// 集合，逆自然顺序
        List<String> strs = Arrays.asList("c++", "java", "php");
        Collections.sort(strs, Collections.reverseOrder()); // 降序
        System.out.println(strs);                           // [php, java, c++]

二、练习题

1、斗地主，最后发到玩家手中的牌是无序的

public class DemoDDZ {
    public static void main(String[] args) {

        // 创建一个ArrayList存储扑克牌
        ArrayList<String> poker = new ArrayList<>();

        /**
         * 1、备牌 普通牌：13*4、特殊牌：大王、小王
         */
        // 普通牌：两个数组，嵌套循环，匹配扑克
        String[] numbers = 
        {"2", "A", "K", "Q", "J", "10", "9", "8", "7", "6", "5", "4", "3"}; // 数值
        String[] colors = {"♤", "♥", "♣", "♦"};                             // 花色
        for (String color : colors) {
            for (String number : numbers) {
                poker.add(color + number); // 形式：花色+数值
            }
        }
        // 特殊牌：最后放入大王、小王
        poker.add("大王");
        poker.add("小王");
        // System.out.println("备牌：" + poker);

        /**
         * 2、洗牌 Collections静态方法shuffle，只针对List集合
         */
        Collections.shuffle(poker);
        // System.out.println("洗牌：" + poker);

        /**
         * 3、分牌 四个集合分别存放三位玩家的牌和底牌
         * 如何给三位玩家分牌 取模运算（余数）
         * 对2取模可区分两种情况0，1、对3取模可区分三种情况0，1，2
         * 前面的牌轮流分给三位玩家，最后三张牌做底牌（共54张，索引≥51）
         */
        ArrayList<String> player1 = new ArrayList<>();
        ArrayList<String> player2 = new ArrayList<>();
        ArrayList<String> player3 = new ArrayList<>();
        ArrayList<String> dipai = new ArrayList<>();
        for (int i = 0; i < poker.size(); i++) {
            if (i >= 51) { // 先把底牌分了，不然分着分着就没底牌啦
                dipai.add(poker.get(i));
            } else if (i % 3 == 0) {
                player1.add(poker.get(i));
            } else if (i % 3 == 1) {
                player2.add(poker.get(i));
            } else if (i % 3 == 2) {
                player3.add(poker.get(i));
            }
        }

        /**
         * 4、看牌
         */
        System.out.println("玩家1：" + player1);
        System.out.println("玩家2：" + player2);
        System.out.println("玩家3：" + player3);
        System.out.println("底牌：" + dipai);
    }
}

2、斗地主，最后发到玩家手中的牌是有序的

public class DemoDDZ {
    public static void main(String[] args) {
        /*第一步：准备牌*/
        //创建map集合用来存储组装好的牌及其索引       
        HashMap<Integer, String> poker = new HashMap<>();
        
        //创建ArrayList集合存放map集合中各张牌的索引      
        ArrayList<Integer> pokerIndex = new ArrayList<>(); 
        //创建两个集合，分别存储数字和花色      
        ArrayList<String> colors = new ArrayList<>();
        Collections.addAll(colors, "♣", "♦", "♠", "♥");
        ArrayList<String> numbers = new ArrayList<>();
        Collections.addAll(numbers, "2", "A", "K", "Q", "J", "10", "9", "8", "7", "6", "5", "4", "3");
        //先将大王，小王放进去    
        int index = 0;
        poker.put(index, "大王");
        pokerIndex.add(index);
        index++;
        poker.put(index, "小王");
        pokerIndex.add(index);
        index++;
        //嵌套循环两个集合，组装花色和数字     
        for (String number : numbers) {
            for (String color : colors) {
                poker.put(index, color + number);//放入4*13张普通牌：2，A...3 
                pokerIndex.add(index);
                index++;
            }
        }
        
        /*第二步：洗牌*/
        //Collections类中的shuffle方法，只针对List集合
        Collections.shuffle(pokerIndex);
        
        /*第三步：发牌 三位玩家+底牌*/
        ArrayList<Integer> player01 = new ArrayList<>();
        ArrayList<Integer> player02 = new ArrayList<>();
        ArrayList<Integer> player03 = new ArrayList<>();
        ArrayList<Integer> dipai = new ArrayList<>();
        for (int i = 0; i < pokerIndex.size(); i++) {
            if (i >= 51) {
                dipai.add(pokerIndex.get(i));
            } else if (i % 3 == 0) {
                player01.add(pokerIndex.get(i));
            } else if (i % 3 == 1) {
                player02.add(pokerIndex.get(i));
            } else if (i % 3 == 2) {
                player03.add(pokerIndex.get(i));
            }
        }
        
        /*第四步：排序*/
        Collections.sort(player01);
        Collections.sort(player02);
        Collections.sort(player03);
        Collections.sort(dipai);
        
        /*第五步：看牌 根据玩家手中的索引，对应到map集合的value*/
        method("玩家1：", poker, player01);
        method("玩家2：", poker, player02);
        method("玩家3：", poker, player03);
        method("底牌：", poker, dipai);
    }

    public static void method(String name, HashMap<Integer, String> hashMap, ArrayList<Integer> arrayList) {
        System.out.print(name);
        for (int i = 0; i < arrayList.size(); i++) {
            String value = hashMap.get(arrayList.get(i));
            System.out.print(value + " ");
        }
        System.out.println();
    }
}