java小练习，BOOK Library类，生成斗地主，随机生成十组字符字母验证码，输出每个字符出现的次数，字符根据自然排序进行排序，输出为 a:1 e:2 g:1实现斗地主洗牌发牌案例。

本文链接：https://blog.csdn.net/delete_bug/article/details/120713653

本文通过Java实现了一个简单的图书管理类`Book`和图书馆类`Library`，支持图书的增删查操作，并确保不添加重复图书。同时，展示了如何生成10个不重复的随机数，以及斗地主洗牌发牌的模拟过程。此外，还提供了一个读取用户输入字符串并统计字符出现次数的程序。这些案例涵盖了基本的数据结构、集合操作以及随机数生成等Java编程基础知识。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1.定义图书类Book，具有属性账号id，书名name、作者author 和价格price，在创建图书对象时要求通过构造器进行创建，一次性将四个属性全部赋值，

要求账户属性是int型，名称是String型，作者是String型，价格是double,请合理进行封装。

在Book类，添加toString方法，要求返回图书信息字符串，使用\t隔开各信息
要求定义一个图书馆Library类，在图书馆类中添加一个HashSet集合用于保存多本图书

3）在图书馆类中要求能够新增图书

4）在图书馆类中要求可以查看所有添加过的图书

5）不允许添加重复的图书（如果账号id和书名name相同，则认为两本书是相同的）

6）可以根据id删除图书

import java.util.Objects;

public class Book {
    private int  id;
    private String name;
    private  String author;
    private  double price;

    public Book() {
    }

    public Book(int id, String name, String author, double price) {
        this.id = id;
        this.name = name;
        this.author = author;
        this.price = price;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Book{" +
                "id=" + id +
                ", name='" + name + '\t' +
                ", author='" + author + '\t' +
                ", price=" + price +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Book book = (Book) o;
        return id == book.id &&
                Objects.equals(name, book.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, name);
    }
}

import java.util.*;

public class Library {
    Set <Book> set =new HashSet<>();
    Iterator <Book> iterator=set.iterator();
    Book book=new Book();
    public void add(Book book){
        if (set.add(book))
          System.out.println("插入成功");
        else
        System.out.println("插入失败");
    }
    public  void look(){

          if (!iterator.hasNext()){
              for (Book book1 : set) {
                  System.out.println(book1);
              }
       }
    }
    public  boolean delete(int id){
        if(!iterator.hasNext()) {
            for (Book book1 : set) {
                if (id == book1.getId())
                    set.remove(book1);
                return true;
            }
        }
        return  false;
    }
}

public class Test {
    public static void main(String[] args) {
        /*
        * 作者 ：软件2班李裕
        *
        * */
        Book book1=new Book(1,"三国演义","罗贯中",25);
        //测试插入相同数据插入失败案例
        Book book2=new Book(1,"三国演义","罗贯中",25);
        //插入图书馆书
        Book book3=new Book(2,"水浒传","施耐庵",30);
        Library library=new Library();
        library.add(book1);
        library.add(book2);
        library.add(book3);
        /*
         *查看图书馆中的书
        */
       library.look();

       //删除图书
       if (library.delete(2))
           System.out.println("删除成功");
       else
           System.out.println("删除失败");

        System.out.println("************删除后的列表如下*****************");
        /*
        * 查看删除后的图书列表信息
        * */
        library.look();
    }
}

实现结果：
在这里插入图片描述
2.产生10个1~20之间的随机数，要求随机数不能重复

import java.util.HashSet;
import java.util.Iterator;
import java.util.Random;

public class Produce_Random_Number {
    public static void main(String[] args) {
        Random r=new Random();
        HashSet<Integer> hashSet=new HashSet<>();
        while(hashSet.size()<10) {
            int number=r.nextInt(20)+1;
            hashSet.add(number);
        }
        Iterator<Integer> iterator=hashSet.iterator();
        while(iterator.hasNext()) {
            System.out.print(iterator.next()+"  ");
        }

    }
}

在这里插入图片描述
3.实现斗地主洗牌发牌案例。


```java
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Set;

public class DOU_DI_ZHU {
    public static void main(String[] args) {
        HashMap<Integer,String> hashMap = new HashMap<>();
        int count = 0 ;
        hashMap.put(count++,"大鬼");
        hashMap.put(count++,"小鬼");

        ArrayList<String> color = new ArrayList();
        ArrayList<String> num = new ArrayList();
        Collections.addAll(color,"方块", "红桃", "梅花", "黑桃");
        Collections.addAll(num,"K", "Q", "J", "10", "9", "8", "7", "6", "5", "4", "3","2", "A");
        for (String n : num) {
            for (String c : color) {
                hashMap.put(count++,c+n);//1
            }
        }
        System.out.println(hashMap);
        Set<Integer> keySet = hashMap.keySet();
        ArrayList<Integer> numberlist = new ArrayList();
        numberlist.addAll(keySet);
        Collections.shuffle(numberlist);
        ArrayList list01 = new ArrayList();
        ArrayList list02 = new ArrayList();
        ArrayList list03 = new ArrayList();
        ArrayList  remain = new ArrayList();

        for (int i = 0; i <numberlist.size() ; i++) {
            Integer pernum = numberlist.get(i);
            if(i>=51){
                remain.add(pernum);
            }else {
                if (i%3==0){
                    list01.add(pernum);
                }
                else if (i%3==1){
                    list02.add(pernum);

                }else if (i%3==2){
                    list03.add(pernum);
                }

            }
        }
        Collections.sort(list01);
        Collections.sort(list02);
        Collections.sort(list03);
        Collections.sort(remain);
        ArrayList<String> player1= new ArrayList<>();
        ArrayList<String> player2= new ArrayList<>();
        ArrayList<String> player3= new ArrayList<>();
        ArrayList<String> dipai01= new ArrayList<>();

        for (Object s : list01) {
            player1.add(hashMap.get(s));
        }for (Object s : list02) {
            player2.add(hashMap.get(s));
        }for (Object s : list03) {
            player3.add(hashMap.get(s));
        }for (Object s : remain) {
            dipai01.add(hashMap.get(s));
        }

        System.out.println("第一个玩家的牌"+player1);
        System.out.println("第二个玩家的牌"+player2);
        System.out.println("第三个玩家的牌"+player3);
        System.out.println(dipai01);
    }
}

![在这里插入图片描述](https://img-blog.csdnimg.cn/c0ff1bb8ccab42109c1b4772030c626c.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5YeM5pmo6YeM55qE5peg6IGK5Lq6,size_20,color_FFFFFF,t_70,g_se,x_16)
4.编写程序，从键盘输入字符串，输出每个字符出现的次数，字符根据自然排序进行排序，输出格式为 a:1 e:2 g:1 ....

```java
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class Count_strings {
    public static void main(String[] args) {
        Count_strings sp = new Count_strings();
        sp.putString();
    }
    public static void putString(){
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String str = scan.next();
        //输入字符串
        for (int i = 0; i < str.length(); i++){
            System.out.print(str.charAt(i) + " ");
        }

        System.out.println();
        //用来存储字符串以及出现的次数
        HashMap <Character, Integer> ha = new HashMap<>();
        Map<Character, ArrayList<Number>> arr = new HashMap<Character,ArrayList<Number>>();

        for (int i = 0; i < str.length(); i++){
            char c = str.charAt(i);
            if (!ha.containsKey(c)){
                ha.put(c, 1);
                ArrayList<Number> li = new ArrayList<>();
            }else{
                ha.put(c, ha.get(c) + 1);
            }
        }

        System.out.println("输出统计次数：");
        //通过将Map中所有的键存入到set集合中。因为set具备迭代器。所有可以迭代方式取出所有的键，
        // 再根据get方法。获取每一个键对应的值。 keySet():迭代后只能通过get()取key
        for (Character c : ha.keySet()) {
            System.out.print(c +":"  + ha.get(c)+"  ");

        }
    }
}

在这里插入图片描述
5.随机验证码。随机生成十组六位字符组成的验证码。验证码由大小写字母、数字字符组成

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class Confirm_Number {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {

            System.out.println("随机验证码：" + fun());
        }
    }
    public static String  fun() {
        String str = "";
        char num = ' ';
        char[] ch = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
                'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
        char[] ch1 = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
                'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
        char[] ch2 = {'!', '@', '#', '$', '%', '&'};
        char[] ch3 = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'};
        Random random = new Random();
        for (int i = 0; i < 6; i++) {
                int j = random.nextInt(4) + 1;
                switch (j) {
                    case (1): {
                        num=ch[random.nextInt(ch.length)];
                        str+=num;
                        continue;
                    }
                    case (2): {
                       num=ch1[random.nextInt(ch1.length)];
                        str+=num;
                        continue;
                    }

                    case (3): {
                        num=ch2[random.nextInt(ch2.length)];
                        str+=num;
                        continue;
                    }

                    case (4): {
                        num=ch3[random.nextInt(ch3.length)];
                        str+=num;
                        continue;
                    }

                }

            }
        return str;
    }
}