首页 > > 程序设计 > Java技术 >

用斗地主的实例学会使用java Collections工具类

2020-06-05 16:01:43来源：博客园 阅读 ()

新老客户大回馈,云服务器低至5折

用斗地主的实例学会使用java Collections工具类

目录

  • 一、背景
  • 二、概念
    • 1、定义
    • 2、方法
      • 2.1、排序方法
      • 2.2、查找/替换方法
  • 三、斗地主实例
    • 3.1、代码结构
    • 3.2、常量定义
    • 3.3、单只牌类
    • 3.4、玩家类
    • 3.5、主程序
  • 四、深入理解

一、背景

最近在学习数据结构和算法的过程中频繁用到了Collections工具类，这是开发中的一把利器，简化了许多涉及集合的编码，该文将通过实例对此工具类进入深入剖析。

二、概念

1、定义

java.util.Collections
是一个包装类。它包含有各种有关集合操作的静态多态方法。此类不能实例化，就像一个工具类，服务于Java的集合框架。

public class Collections {
    // 默认构造方法私有化，不允许实例化.
    private Collections() {
    }
    ...
}
2、方法

Collections的方法都为静态方法，主要分为以下几类：该文主要对排序、查找/替换等方法进行解析。
在这里插入图片描述

2.1、排序方法
  • 方法定义：
// 反转
public static void reverse(List<?> list)
// 随机排序
public static void shuffle(List<?> list) 
// 按自然排序的升序排序
 public static <T> void sort(List<T> list, Comparator<? super T> c)
// 交换两个索引位置的元素
public static void swap(List<?> list, int i, int j)
// 旋转
public static void rotate(List<?> list, int distance)
2.2、查找/替换方法
// 二分查找
int binarySearch(List<? extends Comparable<? super T>> list, T key)
// 根据定制排序，返回最大元素
int max(Collection coll, Comparator c)
// 根据定制排序，返回最小元素
int min(Collection coll, Comparator c)
// 统计元素出现次数
int frequency(Collection c, Object o)，统计元素出现次数
// 统计targe在list中第一次出现的索引
int indexOfSubList(List list, List target)
// 用新元素替换旧元素
boolean replaceAll(List list, Object oldVal, Object newVal)

三、斗地主实例

3.1、代码结构

在这里插入图片描述

3.2、常量定义
  • 用集合的方式定义扑克牌的花色、牌面数字、大小王。
/**
 * 扑克牌常量定义
 *  * @author zhuhuix
 * @date 2020-06-05
 */
public class Constant {

    // 纸牌花色：黑桃，红心，梅花，方块
    final static List<String> COLORS = new ArrayList<>(
            Arrays.asList(new String[]{"?", "?", "?", "?"}));
    // 牌面数字
    final static List<String> NUMBERS = new ArrayList<>(
            Arrays.asList(new String[]{"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"}));
    // 大王小王
    final static List<String> JOKER = new ArrayList<>(
            Arrays.asList(new String[]{"小王","大王"}));
}
3.3、单只牌类
  • 在单只牌类的定义中，重写了会影响到牌面大小的compareTo比较方法：
    -- 如果是"王"的两只牌的比较，则"大王"大于"小王";
    -- 如果是"王"与“数字牌”之间的比较，则"王"大于“数字牌”；
    -- 如果是“数字牌”相互之间的比较，数字大的牌则牌面大，如果数字相同，则按花色比较（?<?< ?< ?）（虽然斗地主不按花色排列大小，但程序会按花色大小进行理牌）。
/**
 * 单只牌
 *  * @author zhuhuix
 * @date 2020-06-05
 */
public class Card implements Comparable {

    // 花色
    private String color = "";
    //数字
    private String number = "";

    public Card() {
    }

    public Card(String color, String number) {
        this.color = color;
        this.number = number;
    }

    public String getColor() {
        return this.color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public String getNumber() {
        return this.number;
    }

    public void setNumber(String number) {
        this.number = number;
    }

    @Override
    public String toString() {
        return this.color + this.number;
    }

    @Override
    public int compareTo(Object o) {
        if (o instanceof Card) {
            int thisColorIndex = Constant.COLORS.indexOf(this.getColor());
            int anotherColorIndex = Constant.COLORS.indexOf(((Card) o).getColor());
            int thisNumberIndex = Constant.NUMBERS.indexOf(this.getNumber());
            int anotherNumberIndex = Constant.NUMBERS.indexOf(((Card) o).getNumber());

            // 大小王之间相互比较: 大王大于小王
            if ("JOKER".equals(this.color) && "JOKER".equals(((Card) o).getColor())) {
                    return thisColorIndex > anotherColorIndex ? 1 : -1;
            }

            // 大小王与数字牌之间相互比较：大小王大于数字牌
            if ("JOKER".equals(this.color) && !"JOKER".equals(((Card) o).getColor())) {
                return 1;
            }
            if (!"JOKER".equals(this.color) && "JOKER".equals(((Card) o).getColor())) {
                return -1;
            }

            // 数字牌之间相互比较: 数字不相等，数字大则牌面大；数字相等 ，花色大则牌面大
            if (thisNumberIndex == anotherNumberIndex) {
                return thisColorIndex > anotherColorIndex ? 1 : -1;
            } else {
                return thisNumberIndex > anotherNumberIndex ? 1 : -1;
            }

        } else {
            return -1;
        }
    }
}
3.4、玩家类
  • 玩家类中主要定义了抓牌、洗牌、理牌、找牌、获取最大最小牌、统计炸弹数等成员方法，在这些成员方法中，我们广泛应用了Collections工具类的静态方法。
/**
 1. 玩家
 2.  * @author zhuhuix
 3. @date 2020-06-05
 */
public class Player {

    // 玩家姓名
    private String name;

    // 玩家类型：农民/地主
    private String type;

    // 抓到的牌
    private List<Card> cards;

    public Player(String name, String type) {
        this.name = name;
        this.type = type;
        this.cards = new ArrayList<>();
    }

    // 洗牌 shuffle
    public void shuffle() {
        Collections.shuffle(this.cards);
    }

    // 理牌 sort
    public void sort() {
        Collections.sort(this.cards, Card::compareTo);
    }

    // 抓牌
    public void draw(Card card) {
        this.cards.add(card);
    }

    // 出牌
    public void play(Card card) {
        this.cards.remove(card);
    }

    // 找出最大牌 max
    public Card max() {
        return Collections.max(this.cards, Card::compareTo);
    }

    // 找出最小牌 min
    public Card min() {
        return Collections.min(this.cards, Card::compareTo);
    }

    // 找到指定牌的位置 binarySearch
    public int binarySearch(Card card) {
        return Collections.binarySearch(this.cards, card, Card::compareTo);
    }

    // 统计有几手炸弹 frequency
    public int frequency() {
        int count = 0;
        List<String> numbers= new ArrayList<>();
        List<String> colors= new ArrayList<>();
        for (int i = 0; i < this.cards.size(); i++) {
            colors.add(this.cards.get(i).getColor());
            numbers.add(this.cards.get(i).getNumber());
        }
        for (int j = 0; j < Constant.NUMBERS.size(); j++) {
            if (Collections.frequency(numbers, Constant.NUMBERS.get(j)) == 4) {
                count++;
            }
        }
        if (Collections.frequency(colors, "JOKER") == 2) {
            count++;
        }
        return count;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public List<Card> getCards() {
        return cards;
    }

    public void setCards(List<Card> cards) {
        this.cards = cards;
    }

    @Override
    public String toString() {
        StringBuilder poker = new StringBuilder("[");
        Iterator<Card> iterator = this.cards.iterator();
        while (iterator.hasNext()) {
            poker.append(iterator.next().toString() + ",");
        }
        poker.setCharAt(poker.length() - 1, ']');
        return this.getType() + ":" + this.getName() + "拿到" + this.cards.size() + "张牌：" + poker;
    }
3.5、主程序
  1. 生成一整副牌;
  2. 设置3个玩家，其中两个为农民，一个为地主；
  3. 3人轮流抓牌，地主多拿三张牌；
  4. 玩家理牌看牌（找到最大牌最小牌）；
  5. 判断大王是否在地主手上？
  6. 统计各个玩家手上有几个炸弹？
/**
 * 斗地主的主程序
 *
 * @author zhuhuix
 * @date 2020-6-5
 */
public class PlayDemo {

    public static void main(String[] args) {

        // 生成一副扑克牌
        Poker poker = new Poker();
        System.out.println("扑克牌共" + poker.getCardCount() + "只");

        // 设置三个玩家，并设定两人为农民，一个为地主
        int playCount = 3;
        Player player1 = new Player("玩家1", "农民");
        Player player2 = new Player("玩家2", "农民");
        Player player3 = new Player("玩家3", "地主");

        // 三个玩家按顺序抓牌
        int i;
        for (i = 0; i < poker.getCardCount() - playCount; i++) {
            if (i % playCount == 0) {
                player1.draw(poker.getCards().get(i));
            } else if (i % playCount == 1) {
                player2.draw(poker.getCards().get(i));
            } else if (i % playCount == 2) {
                player3.draw(poker.getCards().get(i));
            }
        }

        // 地主拿剩余底牌
        while (i < poker.getCardCount()) {
            player3.draw(poker.getCards().get(i));
            i++;
        }

        // 展示三个玩家洗牌后手上的牌面及最大和最小的牌
        player1.sort();
        System.out.println(player1.toString());
        System.out.println("最大牌是："+player1.max().toString()+",最小牌是："+player1.min().toString());
        player2.sort();
        System.out.println(player2.toString());
        System.out.println("最大牌是："+player2.max().toString()+",最小牌是："+player2.min().toString());
        player3.sort();
        System.out.println(player3.toString());
        System.out.println("最大牌是："+player3.max().toString()+",最小牌是："+player3.min().toString());

        // 大王是否在地主手里
        if (player3.binarySearch(new Card("JOKER","大王"))>=0){
            System.out.println("大王在"+player3.getType()+player3.getName()+"手里");
        }

        // 统计有几手炸弹
        System.out.println(player1.getName()+"手上有"+player1.frequency()+"手炸弹");
        System.out.println(player2.getName()+"手上有"+player2.frequency()+"手炸弹");
        System.out.println(player3.getName()+"手上有"+player2.frequency()+"手炸弹");
    }
}

程序输出如下：
在这里插入图片描述

四、深入理解

  • 我们对其中的一些方法进行源码跟踪
    -- shuffle
 public static void shuffle(List<?> list, Random rnd) {
        int size = list.size();
        if (size < SHUFFLE_THRESHOLD || list instanceof RandomAccess) {
            for (int i=size; i>1; i--)
                swap(list, i-1, rnd.nextInt(i));
        } else {
        	//将集合转化成数组
            Object arr[] = list.toArray();

            //  通过随机数随机交换数组元素位置
            for (int i=size; i>1; i--)
                swap(arr, i-1, rnd.nextInt(i));
			// 通过迭代器将打乱顺序的数组赋值给集合
            ListIterator it = list.listIterator();
            for (int i=0; i<arr.length; i++) {
                it.next();
                it.set(arr[i]);
            }
        }
    }

-- sort

public static <T> void sort(List<T> list, Comparator<? super T> c) {
        list.sort(c);
}
    ...
    default void sort(Comparator<? super E> c) {
        Object[] a = this.toArray();
        //调用数组工具类的排序方法--该方法为改进过的归并排序
        Arrays.sort(a, (Comparator) c);
        ListIterator<E> i = this.listIterator();
        for (Object e : a) {
            i.next();
            i.set((E) e);
        }
    }

-- min/max

public static <T> T min(Collection<? extends T> coll, Comparator<? super T> comp) {
        if (comp==null)
            return (T)min((Collection) coll);

        Iterator<? extends T> i = coll.iterator();
        T candidate = i.next();
		// 通过迭代器循环比较，找到最小的
        while (i.hasNext()) {
            T next = i.next();
            if (comp.compare(next, candidate) < 0)
                candidate = next;
        }
        return candidate;
 }
 
public static <T> T max(Collection<? extends T> coll, Comparator<? super T> comp) {
        if (comp==null)
            return (T)max((Collection) coll);

        Iterator<? extends T> i = coll.iterator();
        T candidate = i.next();
		// 通过迭代器循环比较，找到最大的
        while (i.hasNext()) {
            T next = i.next();
            if (comp.compare(next, candidate) > 0)
                candidate = next;
        }
        return candidate;
}

-- binarySearch

public static <T> int binarySearch(List<? extends T> list, T key, Comparator<? super T> c) {
        if (c==null)
            return binarySearch((List<? extends Comparable<? super T>>) list, key);

        if (list instanceof RandomAccess || list.size()<BINARYSEARCH_THRESHOLD)
            return Collections.indexedBinarySearch(list, key, c);
        else
            return Collections.iteratorBinarySearch(list, key, c);
    }
    ...
    // 二分查找法
    private static <T> int iteratorBinarySearch(List<? extends T> l, T key, Comparator<? super T> c) {
        int low = 0;
        int high = l.size()-1;
        ListIterator<? extends T> i = l.listIterator();

        while (low <= high) {
            int mid = (low + high) >>> 1;
            T midVal = get(i, mid);
            int cmp = c.compare(midVal, key);

            if (cmp < 0)
                low = mid + 1;
            else if (cmp > 0)
                high = mid - 1;
            else
                return mid; // key found
        }
        return -(low + 1);  // key not found
    }

原文链接:https://www.cnblogs.com/zhuhuix/p/13049308.html
如有疑问请与原作者联系

标签：

版权申明：本站文章部分自网络，如有侵权，请联系：west999com@outlook.com
特别注意：本站所有转载文章言论不代表本站观点，本站所提供的摄影照片，插画，设计作品，如需使用，请与原作者联系，版权归原作者所有

上一篇：京东面试，被面试官按头问JVM，绝望

下一篇：Java连载120-反射机制获取构造方法和父类、父接口

相关文章

IDC资讯： 主机资讯 注册资讯 托管资讯 vps资讯 网站建设

网站运营： 建站经验 策划盈利 搜索优化 网站推广 免费资源

网站联盟： 联盟新闻 联盟介绍 联盟点评 网赚技巧

行业资讯： 搜索引擎 网络游戏 电子商务 广告传媒

网络编程： Asp.Net编程 Asp编程 Php编程 Xml编程 Access Mssql Mysql 其它

服务器技术： Web服务器 Ftp服务器 Mail服务器 Dns服务器 安全防护

软件技巧： 其它软件 Word Excel Powerpoint Ghost Vista QQ空间 QQ FlashGet 迅雷

网页制作： FrontPages Dreamweaver Javascript css photoshop fireworks Flash

程序设计： Java技术 C/C++ VB delphi

网络知识： 网络协议 网络安全 网络管理 组网方案 Cisco技术

操作系统： Win2000 WinXP Win2003 Mac OS Linux FreeBSD

热门词条
最新资讯
热门关注
热门标签