javaCollections-斗地主游戏-

Collections

Collections在java.util包中，使用的时候需要导包
Collections是类，仅由静态方法组成或者返回集合，包含对集合进行操作的多态算法
Collections类是针对集合操作的工具类

Collections类的常用方法

方法名	说明
public static < T extends Comparable< ? super T> > void sort (List < T > list)	将指定的列表按升序排序，采用自然排序的形式 参数传递的是List接口的具体实现类对象集合，且集合中的元素所属类必须实现Comparable接口
public static < T > void sort ( List< T > list , comparator<? super T > c )	根据指定的比较器设置的顺序对指定的列表进行排序
public static void reverse （List < ? > list）	反转指定列表中元素的顺序
public static void shuffle （List < ? > list）	使用默认的随机源随机排列指定的列表

注意
Collections常用方法针对的都是List集合。

案例：测试sort、reverse、shuffle方法

// 221
public class CollectionsDemo {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>();

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

        System.out.println(list);
        // 输出内容：[30, 10, 20, 50, 80]

//        System.out.println("------------使用Collections.sort");
        Collections.sort(list);
//        System.out.println(list);
        // 输出内容：[10, 20, 30, 50, 80]

//        Collections.reverse(list);
//        System.out.println(list);
        // 输出内容：[80, 50, 20, 10, 30]

        Collections.shuffle(list);
        System.out.println(list);
        // 输出内容：[20, 10, 30, 80, 50]；[20, 30, 50, 80, 10]；[20, 50, 30, 10, 80]
    }
}

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

需求：
ArrayList存储学生对象，使用Collections对ArrayList进行排序
要求：
按照年龄从大到小排序，年龄相同时，按照姓名的字母顺序排序

案例涉及：
匿名内部类、Comparable、

// 221-test2
public class ArrayListSort {
    public static void main(String[] args) {
        /*需求：ArrayList存储学生对象，使用Collections对ArrayList进行排序
要求：按照年龄从大到小排序，年龄相同时，按照姓名的字母顺序排序*/

        // 创建ArrayList集合
        ArrayList<Student> array = new ArrayList<Student>();
        // 创建Student学生对象
        Student s = new Student("abc",12);
        Student s2 = new Student("bcd",25);
        Student s3 = new Student("bcd",12);

        // 向集合中添加元素
        array.add(s);
        array.add(s2);
        array.add(s3);

        // 对ArrayList中的元素进行排序
        Collection.sort(array);
        // 直接使用会报错。 sort（List< T> list）
        // 原因是：Collection.sort方法 根据其元素的natural ordering 按照升序排序指定的列表。sort（List< T> list）需要T对象所属类继承Comparable类，并重写compareTo方法。
        
        // 采用sort(List<T> list,Comparator< ? super T > c)采用比较器的形式
        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 st:array){
            System.out.println(st.getAge() + ", " + st.getName());
        }
        // 输出结果：12, abc
        //12, bcd
        //25, bcd

    }
}

分析比较

• 向集合ArrayList添加自定义类的对象，使用Collections.sort进行排序的时候，会报错。
  原因
  Collection.sort方法 根据其元素的natural ordering 按照升序指定的列表。sort（List< T> list）需要T对象所属类继承Comparable类，并重写compareTo方法。
  测试案例中添加的元素是自定义类Students的对象，该类实现没有实现Comparable接口。
  解决
  采用Collection.sort ( List< T >list,Comparator< ? super T > c ) 形式采用比较器进行排序

案例2：模拟斗地主

需求：
通过程序实现斗地主过程中的洗牌、发牌和看牌

思路

1 创建一个牌盒，也就是定义一个集合对象，用ArrayList集合实现
	ArrayList<String> array = new ArrayList<String>();
2 往牌盒里面装牌
	array.add(String e);
3 洗牌，把牌打散，用Collections的shuffle方法实现
	Collections.shuffle(array);
4 发牌，遍历集合，给三个玩家发牌
	三个玩家 也定义为ArrayList对象
	for(int i = 0; i<array.size();i++)
5 看牌，三个玩家分别遍历自己的牌
	增强for循环 
	for(元素数据类型 变量名：遍历集合名){}

代码

// 221-test3
public class exerciseDemo {
    public static void main(String[] args) {
        // 创建ArrayList集合，存放纸牌
        ArrayList<String> array = new ArrayList<String>();

        // 集合中存放纸牌
        /*纸牌由花色和数字组成
        * 红桃、梅花、方片、黑桃
        * 数字 = 2 - 10 J Q K A
        * 大王 小王
        * */
        String[] colors = {"♥","♦","♣","♠"};
        String[] numbers = {"2","3","4","5","6","7","8","9","10","J","Q","K","A"};
        for(String color:colors){
            for(String number : numbers){
                array.add(color+number);
            }
        }
        array.add("小王");
        array.add("大王");


        // 洗牌 采用Collections.shuffle方法
        Collections.shuffle(array);
//        System.out.println(array);

        // 发牌，使用ArrayList存储 三个人的牌
        ArrayList<String> wslArr = new ArrayList<String>();
        ArrayList<String> xsArr = new ArrayList<String>();
        ArrayList<String> wcArr = new ArrayList<String>();
        ArrayList<String> dpArr = new ArrayList<String>();

        for(int i = 0 ; i < array.size(); i ++){
            String poker = array.get(i);
            if(i == array.size()-3){
                //说明是最后三张底牌
                dpArr.add(poker);
            }else if(i%3 == 1){
                wslArr.add(poker);
            }else if(i%3 == 2){
                xsArr.add(poker);
            }else{
                wcArr.add(poker);
            }
        }

        // 看牌
        lookPoker("汪苏泷", wslArr);
        lookPoker("许嵩", xsArr);
        lookPoker("魏晨", wcArr);
        lookPoker("底牌", dpArr);

    }
    //看牌 采用方法的形式
    public static void lookPoker(String name,ArrayList<String> array){
        System.out.print(name);
        for(String poker:array){
            System.out.print(poker + " ");
        }
        System.out.println();
    }

}

案例3：模拟斗地主升级版（对牌进行排序）

需求：
通过程序实现斗地主过程中的洗牌，发牌和看牌。
要求：
对牌进行排序。

思路

1 创建HashMap集合，键是编号，值是牌
	原因：因为涉及排序和牌值，所以采用键值对对象。排序是按照编号来的
2 创建ArrayList 存储编号
3 创建花色数组和点数数组
4 从0开始往HashMap里面存储编号，并存储对应的牌
5 洗牌（洗的是编号），用Collections的shuffle（）方法实现
6 发牌（发的是编号），为了保证编号是排序的，创建TreeSet集合接收
7 定义方法看牌（遍历TreeSet集合，获取编号，到HashMap集合找对应的牌）
8 调用看牌方法

代码

// 221-test3
public class exerciseDemo2 {
    public static void main(String[] args){
        // 用于存储编号和扑克牌的具体值
        HashMap<Integer,String> hm = new HashMap<Integer, String>();

        // 用于存储编号，用于排序
        ArrayList<Integer> array = new ArrayList<Integer>();

        // 定义花色和数字
        String[] colors = {"♣","♥","♦","♠"};
        String[] numbers = {"3","4","5","6","7","8","9","10","J","Q","K","A"};
        // 定义编号。
        int index = 0;
        for(String color:colors){
            for(String number:numbers){
                hm.put(index,color + number);
                array.add(index);
                index++;
            }
        }

        // 这里采用具体的数值编号去存储对应的大小王
/*        hm.put(53,"小王");
        hm.put(54, "大王");*/
        // 可以继续使用index 变量进行处理
        hm.put(index,"小王");
        array.add(index);
        index++;
        hm.put(index, "大王");
        array.add(index);

//        System.out.println(hm);
//        System.out.println(array);

		// 洗牌
        Collections.shuffle(array);

        TreeSet<Integer> ts1 = new TreeSet<Integer>();
        TreeSet<Integer> ts2 = new TreeSet<Integer>();
        TreeSet<Integer> ts3 = new TreeSet<Integer>();
        TreeSet<Integer> ts4 = new TreeSet<Integer>();

        // 这里的j是集合arrayList的索引，里面的内容inte，是arrayList的内容，=HashMap的索引
        for(int j = 0 ; j < array.size(); j++ ){
            Integer inte = array.get(j);
            if(j >= array.size()-3){
                ts4.add(inte);
            }else if(j % 3 == 0){
                ts1.add(inte);
            }else if(j % 3 == 1){
                ts2.add(inte);
            }else{
                ts3.add(inte);
            }
        }
//        System.out.println(ts4);

        lookPoker("ts1", ts1, hm);
        lookPoker("ts2", ts2, hm);
        lookPoker("ts3", ts3, hm);
        lookPoker("ts4", ts4, hm);
    }
    public static void lookPoker(String name,TreeSet<Integer> ts,HashMap<Integer,String> hm){
        StringBuilder sb = new StringBuilder();
        sb.append(name + "的牌：");
        for(Integer i : ts ){
            String poker = hm.get(i);
            sb.append(poker).append("，");
        }
        String sPoker = sb.toString();
        System.out.println(sPoker);
    }
}