集合——Collections

Collections

1. 概述

• 注意区别Collection：是单列集合的顶层接口，它表示一组对象，这些对象也称为Collection的元素
• 由静态方法组成
• 是针对集合操作的工具类

2. 常用方法

方法名	说明
public static <T extends Comparable<? super T>> void sort(List list)	将指定的列表按升序排序
public static void reverse(List<?> list)	反转指定列表中元素的顺序
public static void shuffle(List<?> list)	使用默认的随机源随机排列指定的列表

2.1 sort()

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

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

        List<Integer> list = new ArrayList<>();

        list.add(30);
        list.add(20);
        list.add(50);
        list.add(10);

        System.out.println(list);
        
    	Collections.sort(list);//自然顺序 升序排序
        System.out.println(list);//[10, 20, 30, 50]


    }
}

2.2 reverse()

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

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

        List<Integer> list = new ArrayList<>();

        list.add(30);
        list.add(20);
        list.add(50);
        list.add(10);

        System.out.println(list);

      	Collections.reverse(list);//反转
        System.out.println(list);//[10, 50, 20, 30]


    }
}

2.3 shuffle()

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

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

        List<Integer> list = new ArrayList<>();

        list.add(30);
        list.add(20);
        list.add(50);
        list.add(10);

        System.out.println(list);

        Collections.shuffle(list);//随机排序 模拟洗牌
        System.out.println(list);
    }
}

3. 案例

3.1 ArrayList存储学生对象并排序

• 测试类

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

// ArrayList存储学生对象并排序
/*
1.定义学生类
2.创建ArrayList学生对象
3.创建学生对象
4.把学生添加到集合
5.使用Collections对ArrayList集合排序
6.遍历集合
 */
public class Test {
    public static void main(String[] args) {
        //创建ArrayList集合
        ArrayList<Student> array = new ArrayList<>();
        //创建学生对象
        Student s1 = new Student("zhangsan", 16);
        Student s2 = new Student("lisi", 17);
        Student s3 = new Student("wangwu", 18);
        Student s4 = new Student("zhaoliu", 19);
        Student s5 = new Student("heqi", 17);
        //将学生对象添加到ArrayList集合
        array.add(s1);
        array.add(s2);
        array.add(s3);
        array.add(s4);
        array.add(s5);
        //利用Collections.sort进行排序，内部类Comparator给定排序条件
        Collections.sort(array, new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                int num = s1.getAge() - s2.getAge();
                int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
                return num2;
            }
        });
        for (Student s : array) {
            System.out.println(s.getName() + "," + s.getAge());
        }
    }
}

• 学生类

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

3.2 模拟斗地主发牌、洗牌、看牌

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

//模拟洗牌、发牌、看牌
/*
1.创建一个集合对象<牌盒>，用ArrayList集合使用
2.在牌盒里装牌
3.洗牌：Collections.shuffle()
4.发牌：遍历集合，给三个玩家发牌
5.看牌
 */
public class Test01 {
    public static void main(String[] args) {
        //创建ArrayList集合，用于 存放牌
        ArrayList<String> array = new ArrayList<>();

        //创建花色 牌号
        String[] color = {"♦","♠","♥","♣"};
        String[] number = {"2","3","4","5","6","7","8","9","10","J","Q","K","A"};
        //将花色和牌号拼接成牌
        for (String s : color) {
            for (String s1 : number) {
                String s2 = s + s1;
                array.add(s2);
            }
        }
        //大王小王不要落下了
        array.add("大王");
        array.add("小王");
        //将牌的存放顺序打乱
        Collections.shuffle(array);

        //创建四个集合分别存放 三个人的牌和底牌
        ArrayList<String> wx = new ArrayList<>();
        ArrayList<String> hj = new ArrayList<>();
        ArrayList<String> xlj = new ArrayList<>();
        ArrayList<String> dp = new ArrayList<>();

        //发牌 if条件中取余，几个人就跟几取余
        for (int i = 0; i < array.size(); i++) {
            String poker = array.get(i);
            //这里判断是否是最后三张牌
            if (i>=array.size()-3){
                dp.add(poker);
            }else if (i%3 == 0){
                wx.add(poker);
            }else if (i%3 == 1){
                hj.add(poker);
            }else if (i%3 == 2){
                xlj.add(poker);
            }
        }
        //调用方法
        lookpoker("王",wx);
        lookpoker("何",hj);
        lookpoker("辣鸡",xlj);
        lookpoker("底牌",dp);

    }
    //看牌方法
    public static void lookpoker(String name,ArrayList<String> array){
        System.out.println(name + "的牌是：");
        //遍历输出牌
        for (String s : array) {
            System.out.print(s + " ");
        }
        System.out.println();
    }
}

3.2 模拟斗地主Plus

import java.util.*;

/*
1.创建HashMap，键是编号，值是牌
2.创建ArrayList，存储编号
3.创建花色数组和点数数组
4.从0开始往HashMap里面存储编号，并存储对应的牌。同时往ArrayList里面存储编号
5.洗牌(洗的是编号)，用Collections的shuffle()方法实现
6.发牌(发的也是编号，为了保证编号是排序的，创建TreeSet集合接收)
7.定义方法看牌(遍历TreeSet集合，获取编号，到HashMap集合找对应的牌)
8.调用看牌方法

 */
public class TestPlus01 {
    public static void main(String[] args) {
        //创建一个HashMap集合，用于存放编号和牌
        HashMap<Integer, String> hm = new HashMap<>();
        //创建一个ArrayList集合，用于存放编号
        ArrayList<Integer> array = new ArrayList<>();
        //创建花色
        String[] color = {"♦","♠","♥","♣"};
        //创建牌号
        String[] number = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
        //创建一个索引，默认值为0
        int index = 0;
        /*
        这里注意区别上一个案例
         */
        //外层循环，遍历牌号
        for (String s : number) {
            //第二层循环，遍历花色
            for (String s1 : color) {
                String s2 = s1 + s; // 将花色与牌号拼接
                hm.put(index,s2);// 将编号和牌存入HashMap集合
                array.add(index);// 将编号存入ArrayList集合
                index++; //每做一次循环编号+1
            }
        }
        hm.put(index,"小王");
        array.add(index);
        index++;
        hm.put(index,"大王");
        array.add(index);

        //创建TreeSet集合，这里使用TreeSet集合是因为TreeSet集合能保证编号是排序的
        TreeSet<Integer> wx = new TreeSet<Integer>();
        TreeSet<Integer> hj = new TreeSet<Integer>();
        TreeSet<Integer> xlj = new TreeSet<Integer>();
        TreeSet<Integer> dp = new TreeSet<Integer>();
        //随机排序编号
        Collections.shuffle(array);

        //将乱序的编号存入每个TreeSet集合
        for (int i = 0; i < array.size(); i++) {
            Integer key = array.get(i);
            //如果长度大于array.size()-3，就表示只剩三张牌，将三张牌存入底牌
            if (i>= array.size()-3){
                dp.add(key);
            }else if(i%3==0){//取余，几个人就跟几取余
                wx.add(key);
            }else if(i%3==1){
                hj.add(key);
            }else if(i%3==2){
                xlj.add(key);
            }
        }
        //调用方法
        lookpoker("王",wx,hm);
        lookpoker("何",hj,hm);
        lookpoker("辣鸡",xlj,hm);
    }
    //看牌方法 参数列表（姓名，TreeSet集合--存放的是发好的编号，HashMap集合--通过编号这个键获取对应的值）
    public static void lookpoker(String name,TreeSet<Integer> ts,HashMap<Integer, String> hm){
        System.out.println(name + "的牌是：");
        for (Integer key : ts) {
            String poker = hm.get(key);
            System.out.print(poker + " ");
        }
        System.out.println();
    }
}