【经典项目】Java入门，实现斗地主小游戏

news2024/12/24 21:01:08

一、需求分析

实现斗地主游戏可以涉及以下几个关键步骤和思路：

  1. 游戏规则定义：首先，你需要明确斗地主游戏的规则，包括牌的花色和大小、玩家数量、发牌顺序、出牌规则、胜利条件等。

  2. 牌的表示和初始化：定义一套扑克牌的数据结构，可以使用数字或字符表示每张牌，例如使用数字1-54或字符2-3A等。然后，初始化一副完整的牌，并进行洗牌操作。

  3. 发牌和牌局管理：根据游戏规则，按照特定的发牌顺序将牌分发给玩家，可以使用列表或数组来保存每个玩家手中的牌。同时，需要维护当前牌局的状态，例如当前轮到哪个玩家出牌、当前出牌的牌型和大小等。

  4. 出牌逻辑和判断：实现出牌阶段的逻辑，根据规则判断玩家出的牌是否合法，并进行相应的处理。需要考虑牌型的判断（如单牌、对子、顺子、炸弹等）和大小比较，以及特殊牌型的处理（如王炸）。

  5. AI策略和智能出牌：如果要实现AI玩家，你可以设计一套策略来指导AI玩家在出牌时的决策。这可能涉及牌型的分析、记忆其他玩家出的牌、考虑当前胜利条件、权衡出牌的风险等。

  6. 回合轮换和胜利条件判断：在游戏中，玩家的出牌轮换，直到其中一位玩家出完所有手牌或达到游戏规定的胜利条件。需要在每轮出牌后更新当前出牌玩家，并判断是否满足胜利条件。

  7. 用户界面和交互：可以通过命令行界面、图形界面或网络界面等方式，提供用户与游戏进行交互的界面。用户可以进行出牌、pass、查看牌等操作。

  8. 异常处理和错误检测：要考虑用户输入的合法性检查和异常处理，以避免程序崩溃或发生错误。

以上是一个基本的斗地主游戏实现的思路，具体的实现细节会有所不同，可以根据自己的编程语言和技术选择进行具体的开发。

二、主要实现思路

【文字思路】：

  1. 先创建HashMap,键是编号，值是牌
  2. 创建ArrayList，存储编号
  3. 创建花色数组和点数数组
  4. 从0开始往HashMap里面存储编号，并存储对应的牌，同时往ArrayList里面存储编号
  5. 洗牌(洗的是编号)，用Collections的shuffle()方法实现
  6. 发牌(洗的是编号)，用Collections的shuffle()方法实现
  7. 发牌(发的也是编号，为了保证编号是排序的，创建TreeSet集合接收)
  8. 定义方法看牌(遍历TreeSet集合，获取编号，到HashMap集合找对应的牌)
  9. 最后调用看牌方法。

【图片思路】

【发牌结果】

【主要代码】

public class PlayerOperation extends Thread {

    //游戏主界面
    GameJFrame gameJFrame;

    //是否能够出牌
    boolean isRun = true;

    //倒计时
    int i;

    public PlayerOperation(GameJFrame m, int i) {
        this.gameJFrame = m;
        this.i = i;
    }

    @Override
    public void run() {
        while (i > -1 && isRun) {
            gameJFrame.time[1].setText("倒计时:" + i--);
            sleep(1);
        }
        if (i == -1) {
            gameJFrame.time[1].setText("不抢");
        }
        gameJFrame.landlord[0].setVisible(false);
        gameJFrame.landlord[1].setVisible(false);
        for (Poker poker2 : gameJFrame.playerList.get(1)) {
            poker2.setCanClick(true);// 可被点击
        }

        if (gameJFrame.time[1].getText().equals("抢地主")) {
            gameJFrame.playerList.get(1).addAll(gameJFrame.lordList);
            openlord(true);
            sleep(2);
            Common.order(gameJFrame.playerList.get(1));
            Common.rePosition(gameJFrame, gameJFrame.playerList.get(1), 1);
            gameJFrame.publishCard[1].setEnabled(false);
            setlord(1);
        } else {
            if (Common.getScore(gameJFrame.playerList.get(0)) < Common.getScore(gameJFrame.playerList.get(2))) {
                gameJFrame.time[2].setText("抢地主");
                gameJFrame.time[2].setVisible(true);
                setlord(2);
                openlord(true);
                sleep(3);
                gameJFrame.playerList.get(2).addAll(gameJFrame.lordList);
                Common.order(gameJFrame.playerList.get(2));
                Common.rePosition(gameJFrame, gameJFrame.playerList.get(2), 2);
                openlord(false);
            } else {
                gameJFrame.time[0].setText("抢地主");
                gameJFrame.time[0].setVisible(true);
                setlord(0);
                openlord(true);
                sleep(3);
                gameJFrame.playerList.get(0).addAll(gameJFrame.lordList);
                Common.order(gameJFrame.playerList.get(0));
                Common.rePosition(gameJFrame, gameJFrame.playerList.get(0), 0);
                openlord(false);
            }
        }
        gameJFrame.landlord[0].setVisible(false);
        gameJFrame.landlord[1].setVisible(false);
        turnOn(false);
        for (int i = 0; i < 3; i++) {
            gameJFrame.time[i].setText("不要");
            gameJFrame.time[i].setVisible(false);
        }
        gameJFrame.turn = gameJFrame.dizhuFlag;
        while (true) {

            if (gameJFrame.turn == 1) {

                if (gameJFrame.time[0].getText().equals("不要") && gameJFrame.time[2].getText().equals("不要"))
                    gameJFrame.publishCard[1].setEnabled(false);
                else {
                    gameJFrame.publishCard[1].setEnabled(true);
                }
                turnOn(true);
                timeWait(30, 1);
                turnOn(false);
                gameJFrame.turn = (gameJFrame.turn + 1) % 3;
                if (win())
                    break;
            }
            if (gameJFrame.turn == 0) {
                computer0();
                gameJFrame.turn = (gameJFrame.turn + 1) % 3;
                if (win())
                    break;
            }
            if (gameJFrame.turn == 2) {
                computer2();
                gameJFrame.turn = (gameJFrame.turn + 1) % 3;
                if (win())
                    break;
            }
        }
    }

    //定义一个方法用来暂停N秒
    //参数为等待的时间
    //因为线程中的sleep方法有异常，直接调用影响阅读
    public void sleep(int i) {
        try {
            Thread.sleep(i * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void openlord(boolean is) {
        for (int i = 0; i < 3; i++) {
            if (is)
                gameJFrame.lordList.get(i).turnFront();
            else {
                gameJFrame.lordList.get(i).turnRear();
            }
            gameJFrame.lordList.get(i).setCanClick(true);
        }
    }

    public void setlord(int i) {
        Point point = new Point();
        if (i == 1) {
            point.x = 80;
            point.y = 430;
            gameJFrame.dizhuFlag = 1;
        }
        if (i == 0) {
            point.x = 80;
            point.y = 20;
            gameJFrame.dizhuFlag = 0;
        }
        if (i == 2) {
            point.x = 700;
            point.y = 20;
            gameJFrame.dizhuFlag = 2;
        }
        gameJFrame.dizhu.setLocation(point);
        gameJFrame.dizhu.setVisible(true);
    }

    public void turnOn(boolean flag) {
        gameJFrame.publishCard[0].setVisible(flag);
        gameJFrame.publishCard[1].setVisible(flag);
    }

    public void computer0() {
        timeWait(1, 0);
        ShowCard(0);

    }

    public void computer2() {
        timeWait(1, 2);
        ShowCard(2);

    }

    public void ShowCard(int role) {
        int orders[] = new int[]{4, 3, 2, 1, 5};
        Model model = Common.getModel(gameJFrame.playerList.get(role), orders);
        ArrayList<String> list = new ArrayList<>();
        if (gameJFrame.time[(role + 1) % 3].getText().equals("不要") && gameJFrame.time[(role + 2) % 3].getText().equals("不要")) {
            if (model.a123.size() > 0) {
                list.add(model.a123.get(model.a123.size() - 1));
            } else if (model.a3.size() > 0) {
                if (model.a1.size() > 0) {
                    list.add(model.a1.get(model.a1.size() - 1));
                } else if (model.a2.size() > 0) {
                    list.add(model.a2.get(model.a2.size() - 1));
                }
                list.add(model.a3.get(model.a3.size() - 1));
            } else if (model.a112233.size() > 0) {
                list.add(model.a112233.get(model.a112233.size() - 1));
            } else if (model.a111222.size() > 0) {
                String name[] = model.a111222.get(0).split(",");

                if (name.length / 3 <= model.a1.size()) {
                    list.add(model.a111222.get(model.a111222.size() - 1));
                    for (int i = 0; i < name.length / 3; i++)
                        list.add(model.a1.get(i));
                } else if (name.length / 3 <= model.a2.size()) {
                    list.add(model.a111222.get(model.a111222.size() - 1));
                    for (int i = 0; i < name.length / 3; i++)
                        list.add(model.a2.get(i));
                }

            } else if (model.a2.size() > (model.a111222.size() * 2 + model.a3.size())) {
                list.add(model.a2.get(model.a2.size() - 1));
            } else if (model.a1.size() > (model.a111222.size() * 2 + model.a3.size())) {
                list.add(model.a1.get(model.a1.size() - 1));
            } else if (model.a4.size() > 0) {
                int sizea1 = model.a1.size();
                int sizea2 = model.a2.size();
                if (sizea1 >= 2) {
                    list.add(model.a1.get(sizea1 - 1));
                    list.add(model.a1.get(sizea1 - 2));
                    list.add(model.a4.get(0));

                } else if (sizea2 >= 2) {
                    list.add(model.a2.get(sizea1 - 1));
                    list.add(model.a2.get(sizea1 - 2));
                    list.add(model.a4.get(0));

                } else {
                    list.add(model.a4.get(0));

                }

            }
        } else {

            if (role != gameJFrame.dizhuFlag) {
                int f = 0;
                if (gameJFrame.time[gameJFrame.dizhuFlag].getText().equals("不要")) {
                    f = 1;
                }
                if ((role + 1) % 3 == gameJFrame.dizhuFlag) {
                    if ((Common.jugdeType(gameJFrame.currentList.get((role + 2) % 3)) != PokerType.c1
                            || Common.jugdeType(gameJFrame.currentList.get((role + 2) % 3)) != PokerType.c2)
                            && gameJFrame.currentList.get(gameJFrame.dizhuFlag).size() < 1)
                        f = 1;
                    if (gameJFrame.currentList.get((role + 2) % 3).size() > 0
                            && Common.getValue(gameJFrame.currentList.get((role + 2) % 3).get(0)) > 13)
                        f = 1;
                }
                if (f == 1) {
                    gameJFrame.time[role].setVisible(true);
                    gameJFrame.time[role].setText("不要");
                    return;
                }
            }

            int can = 0;
            if (role == gameJFrame.dizhuFlag) {
                if (gameJFrame.playerList.get((role + 1) % 3).size() <= 5 || gameJFrame.playerList.get((role + 2) % 3).size() <= 5)
                    can = 1;
            } else {
                if (gameJFrame.playerList.get(gameJFrame.dizhuFlag).size() <= 5)
                    can = 1;
            }

            ArrayList<Poker> player;
            if (gameJFrame.time[(role + 2) % 3].getText().equals("不要"))
                player = gameJFrame.currentList.get((role + 1) % 3);
            else
                player = gameJFrame.currentList.get((role + 2) % 3);

            PokerType cType = Common.jugdeType(player);

            if (cType == PokerType.c1) {
                if (can == 1)
                    model = Common.getModel(gameJFrame.playerList.get(role), new int[]{1, 4, 3, 2, 5});
                AI_1(model.a1, player, list, role);
            } else if (cType == PokerType.c2) {
                if (can == 1)
                    model = Common.getModel(gameJFrame.playerList.get(role), new int[]{2, 4, 3, 5, 1});
                AI_1(model.a2, player, list, role);
            } else if (cType == PokerType.c3) {
                AI_1(model.a3, player, list, role);
            } else if (cType == PokerType.c4) {
                AI_1(model.a4, player, list, role);
            } else if (cType == PokerType.c31) {
                if (can == 1)
                    model = Common.getModel(gameJFrame.playerList.get(role), new int[]{3, 1, 4, 2, 5});
                AI_2(model.a3, model.a1, player, list, role);
            } else if (cType == PokerType.c32) {
                if (can == 1)
                    model = Common.getModel(gameJFrame.playerList.get(role), new int[]{3, 2, 4, 5, 1});
                AI_2(model.a3, model.a2, player, list, role);
            } else if (cType == PokerType.c411) {
                AI_5(model.a4, model.a1, player, list, role);
            } else if (cType == PokerType.c422) {
                AI_5(model.a4, model.a2, player, list, role);
            } else if (cType == PokerType.c123) {
                if (can == 1)
                    model = Common.getModel(gameJFrame.playerList.get(role), new int[]{5, 3, 2, 4, 1});
                AI_3(model.a123, player, list, role);
            } else if (cType == PokerType.c112233) {
                if (can == 1)
                    model = Common.getModel(gameJFrame.playerList.get(role), new int[]{2, 4, 3, 5, 1});
                AI_3(model.a112233, player, list, role);
            } else if (cType == PokerType.c11122234) {
                AI_4(model.a111222, model.a1, player, list, role);
            } else if (cType == PokerType.c1112223344) {
                AI_4(model.a111222, model.a2, player, list, role);
            }
            if (list.size() == 0 && can == 1) {
                int len4 = model.a4.size();
                if (len4 > 0)
                    list.add(model.a4.get(len4 - 1));
            }

        }

        gameJFrame.currentList.get(role).clear();
        if (list.size() > 0) {
            Point point = new Point();
            if (role == 0)
                point.x = 200;
            if (role == 2)
                point.x = 550;
            if (role == 1) {
                point.x = (770 / 2) - (gameJFrame.currentList.get(1).size() + 1) * 15 / 2;
                point.y = 300;
            }
            point.y = (400 / 2) - (list.size() + 1) * 15 / 2;
            ArrayList<Poker> temp = new ArrayList<>();
            for (int i = 0, len = list.size(); i < len; i++) {
                List<Poker> pokers = getCardByName(gameJFrame.playerList.get(role), list.get(i));
                for (Poker poker : pokers) {
                    temp.add(poker);
                }
            }
            temp = Common.getOrder2(temp);
            for (Poker poker : temp) {
                Common.move(poker, poker.getLocation(), point);
                point.y += 15;
                gameJFrame.container.setComponentZOrder(poker, 0);
                gameJFrame.currentList.get(role).add(poker);
                gameJFrame.playerList.get(role).remove(poker);
            }
            Common.rePosition(gameJFrame, gameJFrame.playerList.get(role), role);
        } else {
            gameJFrame.time[role].setVisible(true);
            gameJFrame.time[role].setText("不要");
        }
        for (Poker poker : gameJFrame.currentList.get(role))
            poker.turnFront();
    }

    public List getCardByName(List<Poker> list, String n) {
        String[] name = n.split(",");
        ArrayList cardsList = new ArrayList();
        int j = 0;
        for (int i = 0, len = list.size(); i < len; i++) {
            if (j < name.length && list.get(i).getName().equals(name[j])) {
                cardsList.add(list.get(i));
                i = 0;
                j++;
            }
        }
        return cardsList;
    }

    public void AI_3(List<String> model, List<Poker> player, List<String> list, int role) {

        for (int i = 0, len = model.size(); i < len; i++) {
            String[] s = model.get(i).split(",");
            if (s.length == player.size() && getValueInt(model.get(i)) > Common.getValue(player.get(0))) {
                list.add(model.get(i));
                return;
            }
        }
    }

    public void AI_4(List<String> model1, List<String> model2, List<Poker> player, List<String> list, int role) {
        player = Common.getOrder2(player);
        int len1 = model1.size();
        int len2 = model2.size();

        if (len1 < 1 || len2 < 1)
            return;
        for (int i = 0; i < len1; i++) {
            String[] s = model1.get(i).split(",");
            String[] s2 = model2.get(0).split(",");
            if ((s.length / 3 <= len2) && (s.length * (3 + s2.length) == player.size())
                    && getValueInt(model1.get(i)) > Common.getValue(player.get(0))) {
                list.add(model1.get(i));
                for (int j = 1; j <= s.length / 3; j++)
                    list.add(model2.get(len2 - j));
            }
        }
    }

    public void AI_5(List<String> model1, List<String> model2, List<Poker> player, List<String> list, int role) {
        player = Common.getOrder2(player);
        int len1 = model1.size();
        int len2 = model2.size();

        if (len1 < 1 || len2 < 2)
            return;
        for (int i = 0; i < len1; i++) {
            if (getValueInt(model1.get(i)) > Common.getValue(player.get(0))) {
                list.add(model1.get(i));
                for (int j = 1; j <= 2; j++)
                    list.add(model2.get(len2 - j));
            }
        }
    }

    public void AI_1(List<String> model, List<Poker> player, List<String> list, int role) {

        for (int len = model.size(), i = len - 1; i >= 0; i--) {
            if (getValueInt(model.get(i)) > Common.getValue(player.get(0))) {
                list.add(model.get(i));
                break;
            }
        }

    }

    public void AI_2(List<String> model1, List<String> model2, List<Poker> player, List<String> list, int role) {
        player = Common.getOrder2(player);
        int len1 = model1.size();
        int len2 = model2.size();
        if (len1 > 0 && model1.get(0).length() < 10) {
            list.add(model1.get(0));
            System.out.println("王炸");
            return;
        }
        if (len1 < 1 || len2 < 1)
            return;
        for (int len = len1, i = len - 1; i >= 0; i--) {
            if (getValueInt(model1.get(i)) > Common.getValue(player.get(0))) {
                list.add(model1.get(i));
                break;
            }
        }
        list.add(model2.get(len2 - 1));
        if (list.size() < 2)
            list.clear();
    }

    public void timeWait(int n, int player) {

        if (gameJFrame.currentList.get(player).size() > 0)
            Common.hideCards(gameJFrame.currentList.get(player));
        if (player == 1) {
            int i = n;

            while (gameJFrame.nextPlayer == false && i >= 0) {
                gameJFrame.time[player].setText("倒计时:" + i);
                gameJFrame.time[player].setVisible(true);
                sleep(1);
                i--;
            }
            if (i == -1 && player == 1) {

                ShowCard(1);
            }
            gameJFrame.nextPlayer = false;
        } else {
            for (int i = n; i >= 0; i--) {
                sleep(1);
                gameJFrame.time[player].setText("倒计时:" + i);
                gameJFrame.time[player].setVisible(true);
            }
        }
        gameJFrame.time[player].setVisible(false);
    }

    public int getValueInt(String n) {
        String name[] = n.split(",");
        String s = name[0];
        int i = Integer.parseInt(s.substring(2, s.length()));
        if (s.substring(0, 1).equals("5"))
            i += 3;
        if (s.substring(2, s.length()).equals("1") || s.substring(2, s.length()).equals("2"))
            i += 13;
        return i;
    }

    public boolean win() {
        for (int i = 0; i < 3; i++) {
            if (gameJFrame.playerList.get(i).size() == 0) {
                String s;
                if (i == 1) {
                    s = "恭喜你，胜利了!";
                } else {
                    s = "恭喜电脑" + i + ",赢了! 你的智商有待提高哦";
                }
                for (int j = 0; j < gameJFrame.playerList.get((i + 1) % 3).size(); j++)
                    gameJFrame.playerList.get((i + 1) % 3).get(j).turnFront();
                for (int j = 0; j < gameJFrame.playerList.get((i + 2) % 3).size(); j++)
                    gameJFrame.playerList.get((i + 2) % 3).get(j).turnFront();
                JOptionPane.showMessageDialog(gameJFrame, s);
                return true;
            }
        }
        return false;
    }
}

三、效果展示

1、游戏界面

2、地主牌

3、出牌

 四、完整代码获取

经典项目Java入门，实现斗地主小游戏资源-CSDN文库

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1422669.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【Android Studio 启动出错】

【Android Studio 启动出错】

Android Studio版本&#xff1a;2022.3.1 出错前操作&#xff1a; 昨晚开着三四个项目&#xff0c;然后太晚了直接关机睡觉&#xff0c;第二天起来开机&#xff0c;启动Android Studio&#xff0c;就出现了这个问题&#xff1a; Internal error. Please refer to https://co…
阅读更多...
亚信安慧AntDB构建未来数据库典范

亚信安慧AntDB构建未来数据库典范

亚信安慧AntDB是一款数据库管理系统&#xff0c;它采用全球影响力大、社区繁荣、开放度高、生态增长迅速的PG内核。这款系统具有卓越的性能和稳定性&#xff0c;在全球范围内备受用户青睐。 与此同时&#xff0c;AntDB的社区也是充满活力的&#xff0c;用户可以在社区中交流经…
阅读更多...
【C++】类和对象（二）——构造/析构/拷贝构造函数

【C++】类和对象（二）——构造/析构/拷贝构造函数

&#x1f497;个人主页&#x1f497; ⭐个人专栏——C学习⭐ &#x1f4ab;点击关注&#x1f929;一起学习C语言&#x1f4af;&#x1f4ab; 目录 导读1. 默认成员函数2. 构造函数2.1 引入2.2 特性2.3 默认构造函数 3. 析构函数3.1 概念3.2 特性3.3 默认析构函数 4. 拷贝构造函…
阅读更多...
ARM汇编 4.GNU伪指令、内联汇编

ARM汇编 4.GNU伪指令、内联汇编

汇编伪指令格式 标号symbol&#xff08;label&#xff09; 注释符号&#xff1a; 整行注释&#xff1a;# 语句分离&#xff1a;&#xff1b; 立即数前缀&#xff1a;# 或 $ 分段&#xff1a;.section伪操作&#xff0c;用于自定义新的段 .text&#xff1a;代码段.data&am…
阅读更多...
【服务端性能测试】性能测试策略如何做

【服务端性能测试】性能测试策略如何做

一、需求收集 先需要确认本次测试目的是什么&#xff0c;然后再看我们需要用什么参数来判断这个目的是否能够达成。 1.1 业务性能指标参考&#xff1a; TPS、QPS、RT、请求成功率&#xff08;一般请求成功率>99.99%&#xff09; 1.2 硬件性能指标参考&#xff1a; 即服…
阅读更多...
C++ 滑动窗口

C++ 滑动窗口

目录 1、209. 长度最小的子数组 2、3. 无重复字符的最长子串 3、1004. 最大连续1的个数 III 4、1658. 将 x 减到 0 的最小操作数 5、904. 水果成篮 6、438. 找到字符串中所有字母异位词 7、30. 串联所有单词的子串 8、76. 最小覆盖子串 1、209. 长度最小的子数组 思路&…
阅读更多...
超越传统—Clean架构打造现代Android架构指南

超越传统—Clean架构打造现代Android架构指南

超越传统—Clean架构打造现代Android架构指南 1. 引言 在过去几年里&#xff0c;Android应用开发经历了巨大的变革和发展。随着移动设备的普及和用户对应用的期望不断提高&#xff0c;开发人员面临着更多的挑战和需求。传统的Android架构在应对这些挑战和需求时显得有些力不从…
阅读更多...
计算机网络-物理层传输介质（导向传输介质-双绞线 同轴电缆 光纤和非导向性传输介质-无线波 微波 红外线 激光）

计算机网络-物理层传输介质（导向传输介质-双绞线 同轴电缆 光纤和非导向性传输介质-无线波 微波 红外线 激光）

文章目录 传输介质及分类导向传输介质-双绞线导向传输介质-同轴电缆导向传输介质-光纤非导向性传输介质小结 传输介质及分类 物理层规定电气特性&#xff1a;规定电气信号对应的数据 导向传输介质-双绞线 双绞线的主要作用是传输数据和语音信息。它通过将两根导线以特定的方…
阅读更多...
【Effective Objective - C】—— 协议与分类

【Effective Objective - C】—— 协议与分类

【Effective Objective - C】—— 协议与分类 23.通过委托与数据源协议进行对象间通信协议委托模式数据源模式 要点 24.将类的实现代码分散到便于管理的数个分类之中要点 25.总是为第三方类的分类名称加前缀要点 26.勿在分类中声明属性要点&#xff1a; 27.使用 “class-contin…
阅读更多...
cleanmymacX有必要买吗

cleanmymacX有必要买吗

CleanMyMac X是一款被广泛推荐的Mac电脑清理软件。以下是关于是否购买CleanMyMac X的几个关键点&#xff1a; 软件功能&#xff1a;CleanMyMac X具备多项功能&#xff0c;包括但不限于系统垃圾清理、缓存清理、恶意软件移除、隐私保护等。这些功能有助于保持Mac电脑的清洁和性能…
阅读更多...
数据可视化市场概览：五款主流工具的优缺点解析

数据可视化市场概览：五款主流工具的优缺点解析

在数据可视化的世界中&#xff0c;选择一款合适的工具对于提升工作效率和洞察力至关重要。本文将为您介绍五款主流数据可视化工具&#xff0c;包括山海鲸可视化、Echarts、D3.js、Tableau和Power BI&#xff0c;并进行详细比较&#xff0c;帮助您做出明智的选择。 山海鲸可视化…
阅读更多...
【数据结构】（二）线性表List

【数据结构】（二）线性表List

目录 1、基本概念 2、栈&#xff08;Stack&#xff09; 3、队列&#xff08;Queue&#xff09; 4、串&#xff08;String&#xff09; 1、基本概念 &#xff08;1&#xff09;线性表是零或多个数据元素的有限序列。 &#xff08;2&#xff09;数组长度指存储空间长度&…
阅读更多...
一键给家长私发成绩

一键给家长私发成绩

各位老师&#xff0c;你们是否也有过这样的经历&#xff1a;每到考试后&#xff0c;为了将学生的成绩一一发给家长&#xff0c;费尽心思地整理、核对&#xff0c;甚至有时候还要加班。如今&#xff0c;有了易查分&#xff0c;这一切似乎变得轻松起来。但这个功能真的是老师们的…
阅读更多...
【教学类-44-04】20240130 print dashed（虚线字体）制作的数字描字帖

【教学类-44-04】20240130 print dashed（虚线字体）制作的数字描字帖

作品展示&#xff1a;背景需求&#xff1a; 制作绿色数字的数字描字帖 选用字体&#xff1a;print dashed&#xff08;虚线字体&#xff09; 【教学类-44-03】20240111阿拉伯数字字帖的字体&#xff08;三&#xff09;——德彪钢笔行书&#xff08;实线字体&#xff09;和pri…
阅读更多...
Java玩转《啊哈算法》排序之快速排序

Java玩转《啊哈算法》排序之快速排序

心无挂碍&#xff0c;无挂碍故&#xff0c;无有恐怖&#xff0c;远离颠倒梦想&#xff0c;究竟涅槃。 地图 引子代码地址快速排序核心代码优劣完整代码演示 课后习题 引子 搭嘎好&#xff01;本人最近看的《啊哈算法》这本书写的确实不错&#xff0c;生动形象&#xff0c;在保…
阅读更多...
详解SpringCloud微服务技术栈：深入ElasticSearch（2）——自动补全、拼音搜索

详解SpringCloud微服务技术栈：深入ElasticSearch（2）——自动补全、拼音搜索

&#x1f468;‍&#x1f393;作者简介&#xff1a;一位大四、研0学生&#xff0c;正在努力准备大四暑假的实习 &#x1f30c;上期文章&#xff1a;详解SpringCloud微服务技术栈&#xff1a;深入ElasticSearch&#xff08;1&#xff09;——数据聚合 &#x1f4da;订阅专栏&…
阅读更多...
STM32——温湿度LCD显示并上传手机

STM32——温湿度LCD显示并上传手机

STM32——温湿度LCD显示并上传手机 1.LCD1602 硬件接线 D0~D7 – A0~A7 RS – B1 RW – B2 EN – B10 V0 – GND&#xff08;正视看不到显示结果&#xff0c;需要侧着看。否则需要接可调电阻&#xff09; 引脚封装 RS、RW、EN三根信号线经常需要进行拉高/拉低操作&…
阅读更多...
JAVAEE初阶 网络编程（八）

JAVAEE初阶 网络编程（八）

IP协议 认识IP协议 在认识IP协议之前&#xff0c;我们首先要明确IP协议的工作范围或者是用途。 &#xff08;1&#xff09; 地址管理&#xff1a;使用一套地址体系&#xff0c;来描述互联网上各个设备所处的为止。 &#xff08;2&#xff09; 路由选择&#xff1a;数据包如何从…
阅读更多...
使用linux进程管理工具supervisor管理你的多个应用进程（支持web界面）

使用linux进程管理工具supervisor管理你的多个应用进程（支持web界面）

前言 supervisor可以帮你管理进程&#xff0c;你只需要编写配置文件&#xff0c;supervisor便可以方便控制启动&#xff0c;暂停&#xff0c;重启某个进程&#xff0c;你可以编写进程启动命令&#xff0c;来控制supervisor要进行的操作 流程 安装 sudo yum update sudo yum…
阅读更多...
U2net:Going deeper with nested u-structure for salient object detection

U2net:Going deeper with nested u-structure for salient object detection

u2net是目前stable-diffusion-webui默认的抠图算法&#xff0c;但是在电商图场景实测下来&#xff0c;效果是很一般的。 1.introduction 1.能否设计一个新的网络用语SOD&#xff0c;允许从头训练&#xff1b;2.保持高分辨率特征图的同时网络更深。U2net是一种为SOD设计的两级…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023