Java中的Collections类

Collections概述

是针对集合操作的工具类。此类仅由静态方法组合或返回集合，静态方法可以直接通过类名调用。它包含对集合进行操作的多态算法，“包装器”，返回由指定集合支持的新集合，以及其他一些可能的和最终的。

Collections类的常用方法

1.将指定列表按升序排列

    public static <T> void sort(List<T> list, Comparator<? super T> c) {
        Object[] a = list.toArray();
        Arrays.sort(a, (Comparator)c);
        ListIterator<T> i = list.listIterator();
        for (int j=0; j<a.length; j++) {
            i.next();
            i.set((T)a[j]);
        }
    }

2.反转指定列表中元素的顺序

    public static void reverse(List<?> list) {
        int size = list.size();
        if (size < REVERSE_THRESHOLD || list instanceof RandomAccess) {
            for (int i=0, mid=size>>1, j=size-1; i<mid; i++, j--)
                swap(list, i, j);
        } else {
            // instead of using a raw type here, it's possible to capture
            // the wildcard but it will require a call to a supplementary
            // private method
            ListIterator fwd = list.listIterator();
            ListIterator rev = list.listIterator(size);
            for (int i=0, mid=list.size()>>1; i<mid; i++) {
                Object tmp = fwd.next();
                fwd.set(rev.previous());
                rev.set(tmp);
            }
        }
    }

3.使用默认的随机源随机排列指定的列表

    public static void shuffle(List<?> list) {
        Random rnd = r;
        if (rnd == null)
            r = rnd = new Random(); // harmless race.
        shuffle(list, rnd);
    }

常用方法的具体使用：

package daily_Map;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class demoTest {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(12);
        list.add(32);
        list.add(1);
        list.add(66);
        list.add(56);
        list.add(1);
        Collections.sort(list);
        System.out.println(list);
        Collections.reverse(list);
        System.out.println(list);
        Collections.shuffle(list);
        System.out.println(list);
    }
}

输出结果：

[1, 1, 12, 32, 56, 66]
[66, 56, 32, 12, 1, 1]
[56, 1, 1, 12, 32, 66]

案例：ArrayList存储学生对象并排序

需求：ArrayList存储学生对象，使用Collections对ArrayList进行排序
要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序
思路：
1.定义学生类
2.创建ArrayList集合对象
3.创建学生对象
4.将学生对象添加到集合中
5.使用Collections对ArrayList集合排序
6.遍历集合

方法一：在Student类里面实现Comparable接口，重写compareTo()方法，在list排序的时候再调用Collections.sort(list)

package daily_Collections;

public class Student
        implements Comparable<Student> {
    private String name;
    private int age;

    public  Student(){

    }
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Student student = (Student) o;

        if (age != student.age) return false;
        return name != null ? name.equals(student.name) : student.name == null;
    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }
    @Override
    public int compareTo(Student s) {
        int num = this.name.compareTo(s.name);
        int num2 = num==0?this.age-s.age:num;
        return num2;
    }
}

 Collections.sort(stuList);
        System.out.println(stuList);
        for (Student s:stuList){
            System.out.println(s.getName()+","+s.getAge());
        }

方法二：在Collections.sort(list,Comparator)直接传Comparator匿名函数

package daily_Collections;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class CollectionsDemo01 {
    public static void main(String[] args) {
        List<Student> stuList = new ArrayList<>();
        Student stu1 = new Student("AN",19);
        Student stu2 = new Student("OB",19);
        Student stu3 = new Student("CAT",16);
        Student stu4 = new Student("DOLL",19);
        stuList.add(stu1);
        stuList.add(stu2);
        stuList.add(stu3);
        stuList.add(stu4);

        Collections.sort(stuList);
        System.out.println(stuList);
        for (Student s:stuList){
            System.out.println(s.getName()+","+s.getAge());
        }
        System.out.println("-----------------");
        Collections.sort(stuList, new Comparator<Student>(){
            public int compare(Student stu1,Student stu2){
                int num = stu1.getAge()-stu2.getAge();
                int num2 = num ==0?stu1.getName().compareTo(stu2.getName()):num;
                return num2;
            }
        });
        for(Student s:stuList){
            System.out.println(s.getName()+"-"+s.getAge());
        }
    }
}

案例：模拟斗地主实现地主过程中的洗牌，发牌和看牌

需求：通过程序实现斗地主过程中的洗牌，发牌和看牌
思路：
1.创建一个牌盒，也就是定义一个集合对象，用ArrayList集合实现
2.往牌盒里面装牌
3.洗牌，把牌打散，用Collections.shuffle()方法实现
4.发牌，遍历集合，给三个玩家发牌
5.看牌，三个玩家分别遍历自己的牌

package daily_Collections;

import java.util.*;

public class PokerDemo {
    public static void main(String[] args) {
        List<String> allPoker = new ArrayList<>();

        String[] color = {"♦","♣","♥","♠"};
        String[] num = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
        String[] other = {"JOKER","joker"};

        for (String c:color){
            for (String n:num){
               String poker = c+n;
               allPoker.add(poker);
            }
        }
        allPoker.add(other[0]);
        allPoker.add(other[1]);
        System.out.println(allPoker);

        Collections.shuffle(allPoker);
        List<String> play1 = new ArrayList<>();
        List<String> play2 = new ArrayList<>();
        List<String> play3 = new ArrayList<>();
        List<String> dpArray = new ArrayList<>();

        for (int i=0;i<allPoker.size();i++){
            String givePoker = allPoker.get(i);
            if(i>=allPoker.size()-3){
                dpArray.add(givePoker);
            }else if(i%3==0){
                play1.add(givePoker);
            }else if(i%3==1){
                play2.add(givePoker);
            }else if(i%3==2){
                play3.add(givePoker);
            }
        }
        checkPoker("玩家1：",play1);
        checkPoker("玩家2：",play2);
        checkPoker("玩家3: ",play3);
        checkPoker("底牌：",dpArray);

    }
    public static void checkPoker(String name,List array) {
        System.out.print(name);
        for(Object everyPoker:array){
            System.out.print(everyPoker+" ");
        }
        System.out.println();
    }
}

输出结果：

[♦A, ♦2, ♦3, ♦4, ♦5, ♦6, ♦7, ♦8, ♦9, ♦10, ♦J, ♦Q, ♦K, ♣A, ♣2, ♣3, ♣4, ♣5, ♣6, ♣7, ♣8, ♣9, ♣10, ♣J, ♣Q, ♣K, ♥A, ♥2, ♥3, ♥4, ♥5, ♥6, ♥7, ♥8, ♥9, ♥10, ♥J, ♥Q, ♥K, ♠A, ♠2, ♠3, ♠4, ♠5, ♠6, ♠7, ♠8, ♠9, ♠10, ♠J, ♠Q, ♠K, JOKER, joker]
玩家1：♦2 ♣A ♠K ♥3 ♦10 ♠10 ♦9 ♥Q ♠5 ♣10 ♦3 ♠9 ♥A ♣9 ♣6 ♥4 ♦6 
玩家2：♦8 ♦J ♣8 ♥8 ♣3 ♠3 JOKER ♥7 ♣Q ♣J ♦5 joker ♠4 ♠A ♣K ♥K ♣7 
玩家3: ♦K ♥J ♥2 ♠7 ♥9 ♠8 ♦7 ♦A ♠6 ♥10 ♣5 ♣2 ♥5 ♦4 ♦Q ♣4 ♥6 
底牌：♠J ♠2 ♠Q