用鬥地主的例項學會使用java Collections工具類

智慧zhuhuix發表於2020-06-05

一、背景

最近在學習資料結構和演算法的過程中頻繁用到了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、主程式

生成一整副牌;
設定3個玩家，其中兩個為農民，一個為地主；
3人輪流抓牌，地主多拿三張牌；
玩家理牌看牌（找到最大牌最小牌）；
判斷大王是否在地主手上？
統計各個玩家手上有幾個炸彈？

/**
 * 鬥地主的主程式
 *
 * @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
    }

Java —— 集合工具類(Collections 類)
2018-10-23
Java
Java之Collections工具類
2020-10-11
Java
使用Java實現簡單的鬥地主案例
2020-05-09
Java
Java鬥地主專案碎片
2024-11-05
Java
8、用java的ArrayList集合完成模擬鬥地主案例
2020-11-13
Java
Collections工具類
2020-11-01
Collections工具類,可以使用collections工具類對程式碼中的list進行分組
2024-03-23
Java寫的鬥地主遊戲原始碼
2018-08-10
Java遊戲原始碼
用Python破解鬥地主殘局
2018-09-10
Python
6、Collections工具類
2023-02-14
Python鬥地主
2024-10-15
Python
java中String類常用方法的使用與例項
2018-07-28
Java
7、Collections集合工具類
2020-11-13
模擬鬥地主
2024-03-18
tunna工具使用例項
2020-08-19
Java 集合類——Collections（1）
2019-02-26
Java
Java 集合類——Collections（3）
2019-03-10
Java
Java 集合類——Collections（2）
2019-03-05
Java
java中父類宣告子類例項化
2020-11-01
Java
Python學習：類和例項
2018-08-08
Python
賽博鬥地主——使用大語言模型扮演Agent智慧體玩牌類遊戲。
2024-06-05
模型智慧體遊戲
自己實現鬥地主引擎
2018-06-05
獲取Spring容器中Bean例項的工具類(Java泛型方法實現)
2019-01-24
SpringBeanJava泛型
Java 的可變引數與 Collections 類
2023-04-26
Java
管理 Windows 例項的高效方法 —— 使用 WindowExtensions 類
2024-09-20
Windows
Java類初始化和例項化
2018-06-12
Java
java中的Arrays這個工具類你真的會用嗎
2020-06-29
Java
類和例項
2024-06-10
[短文速度-4] new子類是否會例項化父類
2018-09-14
java開發的第十五個部落格(Collections工具類和比較器)
2020-12-31
Java
Python 三人鬥地主程式碼
2018-12-05
Python
Dart - 抽象類的例項化
2020-06-07
Dart抽象
GObject學習筆記（一）類和例項
2024-11-17
GoObject筆記
Collections — OrderedDict類
2019-01-29
例項靜態類
2020-07-31
python 類和例項
2021-09-09
Python
springboot+Java+cocos creater鬥地主，麻將非常的完整棋牌遊戲專案
2019-02-26
Spring BootJava遊戲
Golang多執行緒簡單鬥地主
2020-09-12
Golang執行緒