JAVA斗地主逻辑-控制台版

未排序版：

准备牌->洗牌 -> 发牌 -> 看牌:

App程序入口：

package doudihzu01;

public class App {
    public static void main(String[] args) {


        /*
        作为斗地主程序入口
        这里不写代码逻辑
         */

        //无参创建对象，作为程序启动
        new PokerGame();

    }
}

代码逻辑：

package doudihzu01;
import java.util.ArrayList;
import java.util.Collections;
public class PokerGame {

    //因为是用无参创建对象开始程序，所以代码逻辑要写在无参构造内
    
    //静态代码块内使用了集合，静态内只能使用静态，所以static修饰
    //放在成员位置是为了其他位置好调用
    static ArrayList<String> list = new ArrayList<>();//牌盒


    //静态代码块--随着类的加载而加载
    static {
        /*1.准备牌*/
        //目的：我们要把花色和牌号拼接起来
        String[] color = {"♣", "♠", "♦", "♥"};
        String[] number = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"};
        //定义一个集合用来存放拼接好的牌

        //增强for遍历拼接
        for (String s : color) {
            for (String string : number) {
                list.add(s + string);
            }
        }
        list.add("大王");
        list.add("小王");
    }


    //无参构造
    public PokerGame() {
        /*2.洗牌*/
        Collections.shuffle(list);
        /*3.发牌*/
        //用四个集合来存牌：底牌、玩家1、玩家2、玩家3
        ArrayList<String> lord = new ArrayList<>();
        ArrayList<String> player1 = new ArrayList<>();
        ArrayList<String> player2 = new ArrayList<>();
        ArrayList<String> player3 = new ArrayList<>();
        //遍历打乱好的牌，发牌规则：前三张为底牌，后面轮流发牌
        //因为需要挨个发牌，所以用带索引的遍历方式
        for (int i = 0; i < list.size(); i++) {
            //如果是前三张牌，就做为底牌，添加到集合中
            if (i <= 2) {
                lord.add(list.get(i));
                continue;//直接下一循环，不要再走下面判断了，提升效率
            }
            if (i % 3 == 0) {
                player1.add(list.get(i));
            } else if (i % 3 == 1) {
                player2.add(list.get(i));
            } else {
                player3.add(list.get(i));
            }
        }
        /*4.看牌*/
        //抽取成一个方法
        lookPoker("底牌", lord);
        lookPoker("玩家一", player1);
        lookPoker("玩家二", player2);
        lookPoker("玩家三", player3);
    }

    public static void lookPoker(String name, ArrayList<String> player) {
        System.out.print(name+":");
        for (String s : player) {
            System.out.print(s + "  ");
        }
        System.out.println();
    }

}

底牌:♠Q ♦8 ♣2
玩家一:♦5 ♠A ♦4 ♠5 ♣J 大王 ♠10 ♣10 ♦3 ♦K ♣Q ♠K ♥A ♥7 ♣4 ♠2 ♥K
玩家二:♥5 ♠7 ♦Q ♥2 ♣6 ♣A 小王 ♦7 ♣8 ♠4 ♣K ♥10 ♣9 ♣3 ♦6 ♠6 ♣5
玩家三:♣7 ♥3 ♥8 ♥4 ♠J ♦A ♥6 ♠9 ♠8 ♦9 ♦10 ♦J ♥Q ♠3 ♦2 ♥J ♥9

排序版

：
准备牌->洗牌 -> 发牌 （同时拍好了序）->->看牌
程序入口：

package doudizhu02;
public class App {
    public static void main(String[] args) {
    /*
    作为斗地主程序入口
    这里不写代码逻辑
     */

    //无参创建对象，作为程序启动
    new PokerGame();
    }
}

逻辑实现：

package doudizhu02;

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

public class PokerGame {

    //Map用来放牌号和序号的对应关系,强调的是对应关系，而不是排序，后面用序号获取牌的时候有用
    static HashMap<Integer,String>hm=new HashMap<>();
    //ArrayList用来放序号，到时候发牌就拿单列集合发序号就可以了，看牌的时候拿Map获取对应的牌号即可
    static ArrayList<Integer>list=new ArrayList<>();

    static {
        //准备牌：花色，牌号，目的拼接  花色与牌
        String[] color = {"♦", "♣", "♥", "♠"};
        String[] number = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"};

        //序号从1开始放
        int serialNumber=1;

        for (String n : number) {
            //外循环是牌号，内循环是花色，可以保证小的在前，大的在后:效果是这样♦3 ♣3 ♥3 ♠3 ♦4 ♣4 ♥4 ♠4 ♦5 ♣5 ♥5 ♠5 ♦6 ♣6 ♥6 ♠6 ♦7 ♣7 ♥7 ♠7 ♦8 ♣8 ♥8 ♠8 ♦9 ♣9 ♥9 ♠9 ♦10 ♣10 ♥10 ♠10 ♦J ♣J ♥J ♠J ♦Q ♣Q ♥Q ♠Q ♦K ♣K ♥K ♠K ♦A ♣A ♥A ♠A ♦2 ♣2 ♥2 ♠2
            //如果外循环是花色，内循环是牌号，效果是这样:明显不符合要求♦3 ♦4 ♦5 ♦6 ♦7 ♦8 ♦9 ♦10 ♦J ♦Q ♦K ♦A ♦2 ♣3 ♣4 ♣5 ♣6 ♣7 ♣8 ♣9 ♣10 ♣J ♣Q ♣K ♣A ♣2 ♥3 ♥4 ♥5 ♥6 ♥7 ♥8 ♥9 ♥10 ♥J ♥Q ♥K ♥A ♥2 ♠3 ♠4 ♠5 ♠6 ♠7 ♠8 ♠9 ♠10 ♠J ♠Q ♠K ♠A ♠2
            for (String c : color) {
                hm.put(serialNumber,c+n);//键是序号，值是准备好的牌
                list.add(serialNumber);//序号放入单列集合
                serialNumber++;//序号自增
            }
        }
        hm.put(serialNumber,"小王");//键是序号，值是准备好的牌
        list.add(serialNumber);//序号放入单列集合
        serialNumber++;//序号++
        hm.put(serialNumber,"大王");//键是序号，值是准备好的牌
        list.add(serialNumber);//序号放入单列集合
    }


    public PokerGame() {
        /*洗牌---洗单列集合内的序号即可，因为到时候发牌就是拿单列集合发序号*/
        Collections.shuffle(list);

        /*发牌：*/

        //定义四个单列集合用来存放 发到的序号，又因为TreeSet对于Integer具有*默认排序*的特点
        TreeSet<Integer>lord=new TreeSet<>();//地主牌
        TreeSet<Integer>player1=new TreeSet<>();//玩家一
        TreeSet<Integer>player2=new TreeSet<>();//玩家二
        TreeSet<Integer>player3=new TreeSet<>();//玩家三
        //遍历list序号集合
        for (int i = 0; i < list.size(); i++) {
            //下面就是发牌规则
            // list.get(i)：元素，即牌的序号
            if (i<=2){
                lord.add(list.get(i));
                continue;//当i<=2时只要发地主拍即可，下面不用再判断了，提升效率
            }
            if (i%3==0){
                player1.add(list.get(i));
            } else if (i%3==1) {
                player2.add(list.get(i));
            }else {
                player3.add(list.get(i));
            }
        }

        /*看牌*/
        //就是拿着Map集合将单列集合内的序号获取对应的牌号即可----抽取成一个方法
        lookPoker("底牌", lord);
        lookPoker("玩家1", player1);
        lookPoker("玩家2", player2);
        lookPoker("玩家3", player3);
    }
    public static void lookPoker(String name,TreeSet<Integer>ts){
        System.out.print(name+": ");
        //遍历单列集合
        for (Integer i : ts) {
            //利用Map集合将单列集合内的序号获取到对应的牌号
            System.out.print(hm.get(i)+" ");
        }
        System.out.println();//每获取完一个集合的牌后换行
    }
}

底牌: ♥5 ♥6 ♥Q
玩家1: ♣3 ♥3 ♣4 ♣5 ♠6 ♥7 ♥8 ♥9 ♥10 ♦J ♥J ♠Q ♦K ♣A ♦2 小王 大王
玩家2: ♥4 ♠5 ♦6 ♣6 ♦7 ♣7 ♦8 ♠8 ♣9 ♠9 ♣10 ♣J ♠J ♦Q ♣Q ♥K ♣2
玩家3: ♦3 ♠3 ♦4 ♠4 ♦5 ♠7 ♣8 ♦9 ♦10 ♠10 ♣K ♠K ♦A ♥A ♠A ♥2 ♠2