集合与斗地主

集合有单列集合和双列集合，

单列集合（接口）：

List

List中的实现类：

ArrayList:

1. 有序
2. 有索引
3. 元素可重复
4. 线程不安全
5. 底层数据结构：数组

LinkedList:

1. 有序
2. 有索引
3. 元素可重复
4. 线程不安全
5. 底层数据结构：双向链表
6. 注意：此实现类本质上无索引，但为了方便才提供了按索引操作的方法。

Vector:

1. 有序
2. 有索引
3. 元素可重复
4. 线程不安全
5. 底层数据结构：数组

Set

HashSet:

1. 无序
2. 元素唯一，不重复
3. 无索引
4. 线程不安全
5. 底层数据结构：哈希表

LinkedHashSet:

1. 有序
2. 元素唯一，不重复
3. 无索引
4. 线程不安全
5. 底层数据结构：哈希表和双向链表

TreeSet:

1. 无序
2. 元素唯一，不重复
3. 无索引
4. 线程不安全
5. 底层数据结构：红黑树
6. 可以给元素排序

Collections工具类

斗地主经典案例

我们建一个pojo包里面放实体类牌类，里面有两种属性，花色和数字

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * @author Young Jun
 * @creat 2024-03-21-11:16
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Card {
    private String color;
    private String number;

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

这其中所用到的注释是一个叫做lombok的插件，去搜用法很方便，我这就不说了

再建立一个dao包里面的CardLib类中存放数据

import a_homework.a_a_collections.a_a_a_shuffle.pojo.Card;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * @author Young Jun
 * @creat 2024-03-21-11:19
 */
public class CardLib {
    public static List<Card> cards;
    static {
        cards = new ArrayList<Card>(54);
        Collections.addAll(cards,new Card("黑桃","A"),
                new Card("黑桃","2"),new Card("黑桃","3"),new Card("黑桃","4"),
                new Card("黑桃","5"), new Card("黑桃","6"),
                new Card("黑桃","7"),new Card("黑桃","8"),
                new Card("黑桃","9"),new Card("黑桃","10"),
                new Card("黑桃","J"),new Card("黑桃","Q"),
                new Card("黑桃","K"));
        Collections.addAll(cards,new Card("红桃","A"),
                new Card("红桃","2"),new Card("红桃","3"),new Card("红桃","4"),
                new Card("红桃","5"), new Card("红桃","6"),
                new Card("红桃","7"),new Card("红桃","8"),
                new Card("红桃","9"),new Card("红桃","10"),
                new Card("红桃","J"),new Card("红桃","Q"),
                new Card("红桃","K"));
        Collections.addAll(cards,new Card("梅花","A"),
                new Card("梅花","2"),new Card("梅花","3"),new Card("梅花","4"),
                new Card("梅花","5"), new Card("梅花","6"),
                new Card("梅花","7"),new Card("梅花","8"),
                new Card("梅花","9"),new Card("梅花","10"),
                new Card("梅花","J"),new Card("梅花","Q"),
                new Card("梅花","K"));
        Collections.addAll(cards,new Card("方块","A"),
                new Card("方块","2"),new Card("方块","3"),new Card("方块","4"),
                new Card("方块","5"), new Card("方块","6"),
                new Card("方块","7"),new Card("方块","8"),
                new Card("方块","9"),new Card("方块","10"),
                new Card("方块","J"),new Card("方块","Q"),
                new Card("方块","K"));
        Collections.addAll(cards,new Card("大王",""),new Card("小王",""));
    }

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

静态变量cards集合中存放牌,并且给一个getCards()方法获取此集合

再创建一个测试类Test

import a_homework.a_a_collections.a_a_a_shuffle.dao.CardLib;
import a_homework.a_a_collections.a_a_a_shuffle.pojo.Card;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;
import java.util.stream.Collectors;

/**
 * @author Young Jun
 * @creat 2024-03-21-11:16
 */
public class Test {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        List<Card> cards = CardLib.getCards();
        Collections.shuffle(cards);
        List<Card> p1 = new ArrayList<Card>();
        List<Card> p2 = new ArrayList<Card>();
        List<Card> p3 = new ArrayList<Card>();
        for (int i = cards.size()-1; i >=3; i--) {
            if (i%3==0){
                p1.add(cards.get(i));
            }if (i%3==1){
                p2.add(cards.get(i));
            }if (i%3==2){
                p3.add(cards.get(i));
            }
        }
        System.out.println("谁要地主牌");
        System.out.println("1.玩家一");
        System.out.println("2.玩家二");
        System.out.println("3.玩家三");
        switch (sc.nextInt()){
            case 1:
                dealCards(p1);
                break;
            case 2:
                dealCards(p2);
                break;
            case 3:
                dealCards(p3);
                break;
        }
        System.out.println("玩家一:");
        System.out.println(p1);
        System.out.println("玩家二:");
        System.out.println(p2);
        System.out.println("玩家三:");
        System.out.println(p3);

    }

    private static void dealCards(List<Card> person) {
        person.addAll(CardLib.getCards().stream().limit(3).collect(Collectors.toList()));
    }
}

List<Card> cards = CardLib.getCards();
Collections.shuffle(cards);

获取牌库，并使用Collections中的shuffle方法打乱顺序

List<Card> p1 = new ArrayList<Card>();
List<Card> p2 = new ArrayList<Card>();
List<Card> p3 = new ArrayList<Card>();
for (int i = cards.size()-1; i >=3; i--) {
if (i%3==0){
p1.add(cards.get(i));
}if (i%3==1){
p2.add(cards.get(i));
}if (i%3==2){
p3.add(cards.get(i));
}
}

定义三个集合，分别表示三个人

从牌库的最后开始倒序循环，对3取余，分别发给三个人牌

System.out.println("谁要地主牌");
System.out.println("1.玩家一");
System.out.println("2.玩家二");
System.out.println("3.玩家三");
switch (sc.nextInt()){
case 1:
dealCards(p1);
break;
case 2:
dealCards(p2);
break;
case 3:
dealCards(p3);
break;
}
System.out.println("玩家一:");
System.out.println(p1);
System.out.println("玩家二:");
System.out.println(p2);
System.out.println("玩家三:");
System.out.println(p3);

看用户输入几就是第几个人需要地主牌

dealCards()方法就是发地主牌方法

private static void dealCards(List<Card> person) {
person.addAll(CardLib.getCards().stream().limit(3).collect(Collectors.toList()));
}

这里面所用的是集合的流处理方式,

CardLib.getCards().stream().limit(3).collect(Collectors.toList())

一步一步解析：

1. 获取牌库CardLib.getCards()
2. 进行流处理.stream()
3. 取前三个，因为之前的循环中我们是从后往前取，所以现在只需要取前三个.limit(3)
4. 把取到的这三个用.collect(Collectors.toList())这个方法收集为集合
5. 然后使用集合中的.addAll()方法加入到玩家的手中