笔记：Java中Conllections运用完成模拟斗地主

听原来是雨落

已于 2022-03-19 20:56:52 修改

阅读量233

点赞数 1

分类专栏： Java 文章标签： java 开发语言

于 2022-03-19 19:24:49 首次发布

本文链接：https://blog.csdn.net/yousfather/article/details/123600643

版权

Java 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

Collection和Collections的区别:

Collection是Java提供的集合接口，存储一组不唯一，无序的对象。它有两个子接口List和Set。
Java中还有一个Collections类，专门用来操作集合类，它提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。

Collections类的概述:
是针对集合操作的工具类
Collections类的常用方法:
- public static <T extends Comparable<? super T>> void sort(List list):将指定的列表按升序排序

public static void reverse(List<?> list): 反转指定列表中元素的顺序
public static void shuffle(List<?> list): 使用默认的随机源随机排列指定的列表

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
/*
       Collections类的常用方法:
    public static <T extends Comparable<? super T>> void sort(List<T> list):将指定的列表按升序排序
    public static void reverse(List<?> list): 反转指定列表中元素的顺序
    public static void shuffle(List<?> list): 使用默认的随机源随机排列指定的列表

 */

public class CollectionsDemo {
    public static void main(String[] args) {
        //创建集合对象
        List<Integer> list = new ArrayList<>();

        //添加元素
        list.add(30);
        list.add(32);
        list.add(23);
        list.add(19);

        //  public static <T extends Comparable<? super T>> void sort(List<T> list):
        //  将指定的列表按升序排序
//        Collections.sort(list);

        //  public static void reverse(List<?> list):
        //  反转指定列表中元素的顺序
//        Collections.reverse(list);

        //  public static void shuffle(List<?> list):
        //  使用默认的随机源随机排列指定的列表
        Collections.shuffle(list);//随机排序，比如引用到洗扑克牌

        System.out.println(list);
    }
}

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

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

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

/*
   ArrayList存储学生对象，使用Collections对ArrayList进行排序
   要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母进行排序
*/
public class CollectionsDemo {
    public static void main(String[] args) {
        //创建ArrayList集合对象
        ArrayList<Student> array = new ArrayList<Student>();

        //创建学生对象
        Student s1 = new Student("zhangtongtong",23);
        Student s2 = new Student("lishanshan",22);
        Student s3 = new Student("xietingting",22);

        //把学生添加到集合
        array.add(s1);
        array.add(s2);
        array.add(s3);

        //使用Collections对ArrayList集合排序
        Collections.sort(array,new Comparator<Student>(){ //比较器，匿名内部类
           public int compare(Student s1,Student s2){
               int num1 = s1.getAge() - s2.getAge();
               int num2 = num1 ==0 ? s1.getName().compareTo(s2.getName()):num1;
               return num2;
           }
        } );

        //遍历集合
        for(Student s:array){
            System.out.println(s.getName()+","+s.getAge());
        }
    }
}

模拟斗地主

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

/*
    模拟斗地主
    思路:
        ①创建-个牌盒,也就是定义一个集合对象，用ArrayList集合实现
        ②往牌盒里面装牌
        ③洗牌，也就是把牌打撒,用Collections的shuffle0方法实现
        ④发牌,也就是遍历集合,给三个玩家发牌
        ⑤看牌,也就是三个玩家分别遍历自己的牌

 */
public class CollectionsDemo {
    public static void main(String[] args) {
        // ①创建-个牌盒,也就是定义一个集合对象，用ArrayList集合实现
        ArrayList<String> array = new ArrayList<>();

        // ②往牌盒里面装牌
        /*
            ♥,♠，♦，♣
            小王，大王
         */
        //定义花色数组
        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()方法实现
        //使用Conllections.shuffle(...);洗牌
        Collections.shuffle(array);

//        System.out.println(array);

        //发牌，也就是遍历集合，给三个玩家发牌
        // ④发牌,也就是遍历集合,给三个玩家发牌
        //创建三个玩家 + 底牌
        ArrayList<String> er1 = new ArrayList<>();//玩家一
        ArrayList<String> er2 = new ArrayList<>();//玩家二
        ArrayList<String> er3 = new ArrayList<>();//玩家三
        ArrayList<String> dp = new ArrayList<>();//底牌
        //遍历
        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){
                er1.add(poker);
            }else if(i%3==1){
                er2.add(poker);
            }else if(i%3==2){
                er3.add(poker);
            }
        }

        //⑤看牌,也就是三个玩家分别遍历自己的牌
        lookPoker("张彤彤",er1);
        lookPoker("李珊珊",er2);
        lookPoker("杜美美",er3);
        lookPoker("底牌",dp);

        }
        public static void lookPoker(String name,ArrayList<String> array){
            System.out.println(name+"的牌是：");
            for (String poker : array){
                System.out.print(poker+" ");
            }
            System.out.println();
    }
}

模拟斗地主增强版（加入排序）

/*
    需求:
        通过程序实现斗地主过程中的提牌，发牌和看牌。要求， 对牌进行携序
    思踏:
        1:创建HoshMop,健是编号，值是牌
        2:创建Arraylist.存储编号
        3:创建花色数组和点数数组
        4:从开始往HoshNop里面存储编号，并存储对应的牌。同时往Arraylist里面存储编号
        5:洗牌(洗的是编号).用Collections的shuffle()方法实现
        6:发牌(发的也是编号。为了保证编号是排序的。创建TreeSet集合接收)_
        7:定义方法看牌(通历TreeSet集合，获取编号，到HashMop集合找对应的牌)
        8:调用看牌方法

 */
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.TreeSet;

public class CollectionsDemo02 {
    public static void main(String[] args) {
        //创建HashMap集合对象，键是编号，值是牌
        HashMap<Integer,String> hm = new HashMap<Integer,String>();

        //创建ArrayList集合对象，存储编号
        ArrayList<Integer> array = new ArrayList<Integer>();

        //创建花色
        String[] colors = {"♦","♠","♥","♣"};
        //创建牌号点数
        String[] numbers = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};

        int index = 0;//创建索引
        //遍历合成一副牌
        for (String number:numbers){
            for(String color:colors){
                hm.put(index,color+number);
                array.add(index);
                index ++;
            }
        }
        hm.put(index,"小王");
        array.add(index);
        index ++;
        hm.put(index,"大王");
        array.add(index);

        //洗牌
        Collections.shuffle(array);
/*
                System.out.println(array);
        创建玩家+底牌
        */

        TreeSet< Integer> er1 = new TreeSet<>();
        TreeSet<Integer> er2 = new TreeSet<>();
        TreeSet<Integer> er3 = new TreeSet<>();
        TreeSet<Integer> dp = new TreeSet<>();

        //遍历集合，发牌
        for (int i = 0;i<array.size();i++){
             int x = array.get(i);
             if(i>=array.size()-3){
                 dp.add(x);
            }else if(i%3==0){
                 er1.add(x);
             }else if(i%3==1){
                 er2.add(x);
             }else if(i%3==2){
                 er3.add(x);
             }
        }
        //调用看牌方法
        lookPoker("张彤彤", er1, hm);
        lookPoker("李珊珊", er2, hm);
        lookPoker("杜美美", er3, hm);
        lookPoker("底牌",dp,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();
    }
}