• 集合练习题

    模拟斗地主

    挑战介绍

    扑克牌都是由 "♠","♥","♣","♦" 4 种花色和 "2,3,4,···,A,J,Q,K," 13 种数字组合形成的 52 张正牌以及 "大王" 和 "小王" 两张副牌组成。本次挑战将结合本章所学知识模拟斗地主的洗牌与发牌过程。具体规则为：使用 54 张牌打乱顺序,三个玩家参与游戏，三人交替摸牌，每人 17 张牌，最后三张留作底牌。

    知识点

    • List 接口
    • 泛型
    • 工具类

    挑战内容

    1. 准备牌：

      定义一个集合，存储 54 张牌。

      定义一个集合，存储四种花色 "♠","♥","♣","♦"。

      定义一个集合，存储 13 个序号。

      可以使用花色集合与数字集合嵌套迭代完成每张牌的组装。

    2. 洗牌：

      牌由 Collections 类的 shuffle() 方法进行随机排序。

    3. 发牌：

      定义四个集合 存储三个玩家的牌和底牌。

    4. 看牌：

      直接打印玩家和底牌集合。

    提示： 循环遍历集合中的每一个元素，判断索引是否大于 51 ，小于 51 的对 3 取模运算，结果 0、1、2 分别对应三个玩家，当元素索引大于 51 的时候就将此牌添加到底牌集合中。

     

    1. import java.util.ArrayList;
    2. import java.util.Collection;
    3. import java.util.Collections;
    4.  
    5. public class Poker {
    6.     public static void main(String[] args) {
    7.         ArrayList array = new ArrayList();
    8.         // 花色数组
    9.         String[] colors = { "♥", "♣", "♦", "♠" };
    10.         // 定义点数数组
    11.         String[] numbers = { "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A" };
    12.  
    13.         for (String col : colors) {
    14.             for (String num : numbers) {
    15.                 array.add(col + num);
    16.             }
    17.         }
    18.         // 添加大小牌
    19.         array.add("大王");
    20.         array.add("小王");
    21. //		System.out.println(array);
    22.  
    23.         // 洗牌
    24.         Collections.shuffle(array);
    25. //		System.out.println(array);
    26.  
    27.         // 给三个玩家发牌
    28.         ArrayList player1 = new ArrayList<>();
    29.         ArrayList player2 = new ArrayList<>();
    30.         ArrayList player3 = new ArrayList<>();
    31.         ArrayList dipai = new ArrayList<>();
    32.  
    33.         for (int i = 0; i < array.size(); i++) {
    34.             String poker = array.get(i);
    35.             if (i >= array.size() - 3) {
    36.                 dipai.add(poker);
    37.             } else if (i % 3 == 0) {
    38.                 player1.add(poker);
    39.             } else if (i % 3 == 1) {
    40.                 player2.add(poker);
    41.             } else if (i % 3 == 2) {
    42.                 player3.add(poker);
    43.             }
    44.         }
    45.  
    46.         // 看牌
    47.         look("玩家: ", player1);
    48.         look("玩家2: ", player2);
    49.         look("玩家3: ", player3);
    50.         look("底牌: ", dipai);
    51.  
    52.     }
    53.  
    54.     //定义看牌的方法
    55.     public static void look(String player, ArrayList arr) {
    56.         System.out.print(player);
    57. //        for (String s : arr) {
    58. //            System.out.print(s + " ");
    59. //        }
    60.         System.out.println(arr);
    61.         
    62.     }
    63. }

    挑战介绍

    蓝桥班有 40 个学生，学号为 180201-180240， 全部参加 Java 集合阶段检测，给出所有同学的成绩 （可随机产生，范围为 50-100），请编写程序将本班 各位同学成绩从高往低排序打印输出。

    知识点

    • List 接口
    • ArrayList 类
    • Collections 类
    • Comparator 接口

    挑战内容

    某班有 40 个学生，学号为 180201-180240， 全部参加 Java 集合阶段检测，给出所有同学的成绩 （可随机产生，范围为 50-100），请编写程序将本班 各位同学成绩从高往低排序打印输出。

    注：成绩相同时学号较小的优先打印。

    要求：打印的信息包含学号、姓名（姓名统一为 “同学 J ”，J 的取值范围为 1 - 40）和成绩。

    挑战要求

    1. 创建一个 Student 类，该类具有 int 类型的学号 id、String 类型的姓名 name、int 类型的成绩 score。

    2. 需要在 Student 类中重写 toString() 方法，格式如下：

      "学号：" + id + ", 姓名：" + name  + ", 成绩：" + score

    3. 创建一个 Results 类，该类为运行类，具有一个公共的静态的集合 data，该集合的泛型为 Student 类型用于储存班级内的学生对象。

    4. 在 Results 类中创建一个公共的静态的 initData() 方法，该方法用于初始化集合 data 存入 40 个学生对象，其中学生的 id 属性从 180201 递增至 180240，name 属性为 J1 至 J40 递增，score 属性为 50 + 50 内的随机数。

    5. 在 Results 类中创建一个公共的静态的 adjust() 方法，该方法用于对集合进行排序，排序规则为按照成绩从高到低。若成绩相同按照学号从小到大打印。

    6. 在 Results 类中创建一个公共的静态的 print() 方法，该方法用于打印集合内的学生对象。

    7. 输出格式请参照「挑战运行效果」，创建的文件名、方法名请按要求书写，为避免后台测试出现问题，请不要擅自修改输出格式。

    1. package org.lanqiao.main;
    2.  
    3. import org.lanqiao.entity.*;
    4.  
    5. import java.util.*;
    6.  
    7. public class Results {
    8.  
    9.     public static List data = new ArrayList();
    10.  
    11.     public static void initData() {
    12.         Random random = new Random();
    13.         int k;
    14.         for (int i = 0; i < 40; i++) {
    15.             k = i + 1;
    16.             Student student = new Student(180201 + i, ("同学" + k), (random.nextInt(50) + 50));
    17.             data.add(student);
    18.         }
    19.     }
    20.  
    21.     public static void adjust() {
    22.         Collections.sort(data, new GradeComparator());
    23.     }
    24.  
    25.     public static void print() {
    26.         for (int i = 0; i < data.size(); i++) {
    27.             Student s = data.get(i);
    28.             System.out.println(s);
    29.         }
    30.     }
    31.  
    32.     //定义一个成绩比较器
    33.     static class GradeComparator implements Comparator {
    34.         @Override
    35.         public int compare(Object o1, Object o2) {
    36.             Student O1 = (Student) o1;
    37.             Student O2 = (Student) o2;
    38.             if(O2.score == O1.score){
    39.                 return O1.id-O2.id;
    40.             }
    41.             return O2.score - O1.score;
    42.         }
    43.  
    44.         public static void main(String[] args) {
    45.             Results results = new Results();
    46.             results.initData();
    47.             results.adjust();
    48.             results.print();
    49.         }
    50.     }
    51.  
    52.  
    53. }
    1. package org.lanqiao.entity;
    2. public class Student {
    3.     public int id;
    4.     String name;
    5.     public int score;
    6.  
    7.     @Override
    8.     public String toString() {
    9.         return "学号：" + id + ", 姓名：" + name  + ", 成绩：" + score;
    10.     }
    11.  
    12.     public Student() {
    13.     }
    14.  
    15.     public Student(int id, String name, int score) {
    16.         this.id = id;
    17.         this.name = name;
    18.         this.score = score;
    19.     }
    20.  
    21.     public int getId() {
    22.         return id;
    23.     }
    24.  
    25.     public void setId(int id) {
    26.         this.id = id;
    27.     }
    28.  
    29.     public String getName() {
    30.         return name;
    31.     }
    32.  
    33.     public void setName(String name) {
    34.         this.name = name;
    35.     }
    36.  
    37.     public int getScore() {
    38.         return score;
    39.     }
    40.  
    41.     public void setScore(int score) {
    42.         this.score = score;
    43.     }
    44. }

    模拟一个图书馆

    挑战介绍

    HashSet 是 Set 接口的典型实现，大多数时候使用 Set 集合时就是使用这个实现类。HashSet 按 Hash 算法来存储集合中的元素，因此具有很好的存取和查找性能。本次挑战将模拟一个图书管理系统，对图书对象进行增加、删除、查询。

    知识点

    • Java 集合

    挑战内容

    使用 HashSet 作为储存容器，模拟一个图书管理系统，该系统可以对容器内的图书进行增加、删除、查询。

    1. 定义图书类 Book，具有属性账号 id，书名 name、作者 author 和价格 price，在创建图书对象时要求通过构造器进行创建，一次性将四个属性全部赋值，要求账户属性是 int 型，名称是 String 型，作者是 String 型，价格是 double，请合理进行封装。
    2. 在 Book 类添加 toString 方法，要求返回图书信息字符串，使用制表符隔开各信息。
    3. 要求定义一个图书馆 Library 类，在图书馆类中添加一个 HashSet 集合用于保存多本图书。
    4. 在图书馆类中要求具有以下方法：addBook()、deleteBook()、selectBook() 。分别能够对图书进行增加、删除、查询。
    5. addBook() 方法的输入规则参照「测试验证」中的截图。
    6. deleteBook() 删除方法通过输入一个图书 id 进行删除指定图书，删除完成后输出“删除成功！”字样。
    7. selectBook() 通过输出所有图书对象的 toString() 方法输出图书信息

    1. package main;
    2.  
    3. import entity.Book;
    4.  
    5. import java.util.*;
    6. import java.util.Iterator;
    7. import static java.lang.System.exit;
    8.  
    9. public class Library {
    10.     static Set set=new HashSet() ;
    11.     static Scanner input = new Scanner(System.in);
    12.     public static void addBook() {
    13.         System.out.println("请输入图书id：");
    14.         int id = input.nextInt();
    15.         System.out.println("请输入书名：");
    16.         String name = input.next();
    17.         System.out.println("请输入作者名");
    18.         String author = input.next();
    19.         System.out.println("请输入价格");
    20.         double price = input.nextDouble();
    21.  
    22.         Book book = new Book(id, name, author, price);
    23.         if ( set.add(book)){
    24.             System.out.println("添加成功!");
    25.         }else {
    26.             System.out.println("添加失败");
    27.         }
    28.     }
    29.     public static void deleteBook() {
    30.         System.out.println("请输入要删除的图书id:");
    31.         int id1=input.nextInt();
    32.         for (Book book1:set){
    33.             if (id1== book1.getId()){
    34.                 set.remove(book1);
    35.                 System.out.println("删除成功！");
    36.             }
    37.         }
    38.     }
    39.     public static void selectBook() {
    40.         System.out.println("以下为所有图书信息！");
    41.         Iterator it=set.iterator();
    42.         //遍历迭代器并输出元素
    43.         while(it.hasNext()) {
    44.             //若不重载Cat类中toString()方法 输出的是地址
    45.             System.out.println(it.next());
    46.         }
    47.     }
    48.  
    49.     public static void menu(){
    50.         System.out.println("------欢迎到蓝桥图书馆------");
    51.         System.out.println("1.添加图书");
    52.         System.out.println("2.查询图书");
    53.         System.out.println("3.删除图书");
    54.         System.out.println("4.退出程序");
    55.         System.out.println("请输入选项：");
    56.     }
    57.     public static void main(String[] args) {
    58.  
    59.         while (true) {
    60.             menu();
    61.  
    62.             int select = input.nextInt();
    63.             switch (select) {
    64.                 case 1:
    65.                     addBook();
    66.                     break;
    67.                 case 2:
    68.                     selectBook();
    69.                     break;
    70.                 case 3:
    71.                     deleteBook();
    72.                     break;
    73.                 case 4:
    74.                     System.out.println("退出成功");
    75.                     exit(-1);
    76.             }
    77.         }
    78.     }
    79. }
    1. package entity;
    2.  
    3. import java.util.Objects;
    4.  
    5. public class Book {
    6.     int id;
    7.     String name;
    8.     String author;
    9.     double price;
    10.  
    11.     public Book(int id, String name, String author, double price) {
    12.         this.id = id;
    13.         this.name = name;
    14.         this.author = author;
    15.         this.price = price;
    16.     }
    17.  
    18.     @Override
    19.     public String toString() {
    20.         return "Book{" +
    21.                 "id=" + id +
    22.                 ", name='" + name + '\'' +
    23.                 ", author='" + author + '\'' +
    24.                 ", price=" + price +
    25.                 '}';
    26.     }
    27.  
    28.     public int getId() {
    29.         return id;
    30.     }
    31.  
    32.     public void setId(int id) {
    33.         this.id = id;
    34.     }
    35.  
    36.     public String getName() {
    37.         return name;
    38.     }
    39.  
    40.     public void setName(String name) {
    41.         this.name = name;
    42.     }
    43.  
    44.     public String getAuthor() {
    45.         return author;
    46.     }
    47.  
    48.     public void setAuthor(String author) {
    49.         this.author = author;
    50.     }
    51.  
    52.     public double getPrice() {
    53.         return price;
    54.     }
    55.  
    56.     public void setPrice(double price) {
    57.         this.price = price;
    58.     }
    59. }

  • 相关阅读:
    两岁的娃，要不要上托班？看完你不用再纠结
    深度学习图像生成在AI去衣技术中的应用与探索
    Java中JVM指什么呢？她拥有哪些功能及特征呢?
    维修派单系统好用吗？如何实现数字化后勤管理？
    华为防火墙基础自学系列 | Hub Spoke IPsec VdPdNd
    蓝桥杯冲刺_二分(正在补题)
    BSA/HSA表面修饰二甘醇酐，人血清白蛋白HSA、牛血清白蛋白BSA偶联二甘醇酐
    JSR303和拦截器
    UI设计师的工作职责 优漫动游
    【数据科学】Scikit-learn[Scikit-learn、加载数据、训练集与测试集数据、创建模型、模型拟合、拟合数据与模型、评估模型性能、模型调整]
  • 原文地址：https://blog.csdn.net/qq_58631644/article/details/126223480