java基础入门-21-【阶段综合案例（带权重的随机&每日一记）】

30、阶段综合案例（带权重的随机&每日一记）

制造假数据

获取姓氏: https://hanyu.baidu.com/shici/detail?pid=0b2f26d4c0ddb3ee693fdb1137ee1b0d&from=kg0

男生名字: http://www.haoming8.cn/baobao/10881.html

获取女生名字: http://www.haoming8.cn/baobao/7641.html

Test1

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.URLConnection;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.Random;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Test1 {
    public static void main(String[] args) throws IOException {
        /*
         制造假数据：
             获取姓氏：https://hanyu.baidu.com/shici/detail?pid=0b2f26d4c0ddb3ee693fdb1137ee1b0d&from=kg0
             获取男生名字：http://www.haoming8.cn/baobao/10881.html
             获取女生名字：http://www.haoming8.cn/baobao/7641.html
        */

        //1.定义变量用来记录网址
        String familyNameNet = "https://hanyu.baidu.com/shici/detail?pid=0b2f26d4c0ddb3ee693fdb1137ee1b0d&from=kg0";
        String boyNameNet = "http://www.haoming8.cn/baobao/10881.html";
        String girlNameNet = "http://www.haoming8.cn/baobao/7641.html";

        //2.爬取数据，把网址上所有的数据拼接成一个字符串
        String familyNameStr = webCrawler(familyNameNet);
        //System.out.println("familyNameStr = " + familyNameStr);

        String boyNameStr = webCrawler(boyNameNet);
        //System.out.println("boyNameStr = " + boyNameStr);

        String girlNameStr = webCrawler(girlNameNet);
        //System.out.println("girlNameStr = " + girlNameStr);

        //3.通过正则表达式，把其中符合要求的数据获取出来
        //  .{4}(，|。)
        //  (.{4})(，|。)
        ArrayList<String> familyNameTempList = getData(familyNameStr, "(.{4})(，|。)", 1);
        System.out.println("familyNameTempList = " + familyNameTempList);

        //..(、|。)
        //(..)(、|。)
        //([\u4E00-\u9FA5]{2})(、|。)
        ArrayList<String> boyNameTempList = getData(boyNameStr, "([\\u4E00-\\u9FA5]{2})(、|。)", 1);
        System.out.println("boyNameTempList = " + boyNameTempList);

        //(.. ){4}..
        ArrayList<String> girlNameTempList = getData(girlNameStr, "(.. ){4}..", 0);
        System.out.println("girlNameTempList = " + girlNameTempList);

        //4.处理数据
        //familyNameTempList（姓氏）
        //处理方案：把每一个姓氏拆开并添加到一个新的集合当中
        ArrayList<String> familyNameList = new ArrayList<>();
        for (String str : familyNameTempList) {
            // 赵钱孙李     周吴郑王    冯陈褚卫    蒋沈韩杨    朱秦尤许
            for (int i = 0; i < str.length(); i++) {
                char c = str.charAt(i);
                //System.out.println("c = " + c);
                familyNameList.add(c + "");
            }
        }
        System.out.println("familyNameList = " + familyNameList);

        //boyNameTempList（男生的名字）
        //处理方案：去除其中的重复方案
        ArrayList<String> boyNameList = new ArrayList<>();
        for (String str : boyNameTempList) {
            if (!boyNameList.contains(str)) {
                boyNameList.add(str);
            }
        }
        System.out.println("boyNameList = " + boyNameList);

        //girlNameTempList（女生的名字）
        //处理方案：把里面的每一个元素用空格进行切割，得到每一个女生的名字
        ArrayList<String> girlNameList = new ArrayList<>();
        for (String str : girlNameTempList) {
            String[] arr = str.split(" ");
            for (int i = 0; i < arr.length; i++) {
                girlNameList.add(arr[i]);
            }
        }
        System.out.println("girlNameList = " + girlNameList);

        //5.生成数据
        //姓名（唯一）-性别-年龄
        ArrayList<String> list = getInfos(familyNameList, boyNameList, girlNameList, 1300, 1400);
        Collections.shuffle(list);
        System.out.println("list = " + list);

        //6.写出数据
        BufferedWriter bw = new BufferedWriter(new FileWriter("day28-myiotest\\file\\names.txt"));
        for (String str : list) {
            bw.write(str);
            bw.newLine();
        }

        //7.释放资源
        bw.close();
    }

    /**
     * 作用：获取男生和女生的信息：张三-男-23
     * <p>
     * 形参
     *
     * @param familyNameList 参数一：装着姓氏的集合
     * @param boyNameList    参数二：装着男生名字的集合
     * @param girlNameList   参数三：装着女生名字的集合
     * @param boyCount       参数四：男生的个数
     * @param girlCount      参数五：女生的个数
     * @return 返回字符串：张三-男-23
     */
    public static ArrayList<String> getInfos(ArrayList<String> familyNameList, ArrayList<String> boyNameList, ArrayList<String> girlNameList, int boyCount, int girlCount) {

        //1.生成男生不重复的名字  张三
        HashSet<String> boyHs = new HashSet<>();
        while (true) {
            if (boyHs.size() == boyCount) {
                break;
            }
            //随机
            Collections.shuffle(familyNameList);
            Collections.shuffle(boyNameList);
            boyHs.add(familyNameList.get(0) + boyNameList.get(0));
        }
        System.out.println("boyHs = " + boyHs);

        //2.生成女生不重复的名字  王二麻子
        HashSet<String> girlHs = new HashSet<>();
        while (true) {
            if (girlHs.size() == girlCount) {
                break;
            }
            //随机
            Collections.shuffle(familyNameList);
            Collections.shuffle(girlNameList);
            girlHs.add(familyNameList.get(0) + girlNameList.get(0));
        }
        System.out.println("girlHs = " + girlHs);

        //3. 赵鸿光-男-23
        //   赵亦曼-女-25
        ArrayList<String> list = new ArrayList<>();
        Random r = new Random();
        //【18 ~ 27】
        //-18  0~9
        //尾巴 + 1  9 + 1 = 10
        for (String boyName : boyHs) {
            // boyName依次表示每一个男生的名字
            int age = r.nextInt(10) + 18;
            list.add(boyName + "-男-" + age);
        }

        //4.生成女生的信息并添加到集合当中
        //【18 ~ 25】
        //-18 0~7
        //尾巴+1 7+1=8
        for (String girlName : girlHs) {
            // girlName依次表示每一个女生的名字
            int age = r.nextInt(8) + 18; //0 ~ 7 + 18 = 18~25
            list.add(girlName + "-女-" + age);
        }

        return list;
    }

    /**
     * 作用：根据正则表达式获取字符串中的数据
     *
     * @param Str   参数一：完整的字符串
     * @param regex 参数二：正则表达式
     * @param index 参数三：获取数据
     *              0：获取符合正则表达式所有的内容
     *              1：获取正则表达式中第一组数据
     *              2：获取正则表达式中第二组数据
     *              ...以此类推
     * @return 返回值：真正相要的数据
     */
    private static ArrayList<String> getData(String Str, String regex, int index) {
        //1.创建集合存放数据
        ArrayList<String> list = new ArrayList<>();

        //2.按照正则表达式的规则，去获取数据
        Pattern pattern = Pattern.compile(regex);

        //3.按照pattern的规则，到Str当中获取数据
        Matcher matcher = pattern.matcher(Str);

        while (matcher.find()) {
            //满足要求的数据进行获取
            //String group = matcher.group(index);
            //System.out.println("group = " + group);
            list.add(matcher.group(index));
        }

        return list;
    }

    /**
     * 作用：从网络中爬取数据，把数据拼接成字符串返回
     *
     * @param net 形参：网址
     * @return 返回值：爬取到的所有数据
     */
    public static String webCrawler(String net) throws IOException {
        //1.定义StringBuilder拼接爬取到的数据
        StringBuilder sb = new StringBuilder();

        //2.创建一个URL对象
        URL url = new URL(net);

        //3.连接上这个网址
        //细节：保证网络是畅通的，而且这个网址是可以链接上的。
        URLConnection conn = url.openConnection();

        //4.读取数据
        //字节流
        //有中文---字节流转换成字符流
        InputStreamReader isr = new InputStreamReader(conn.getInputStream());//字节流转换成字符流
        int ch;
        while ((ch = isr.read()) != -1) {
            sb.append((char) ch);
        }

        //5.释放资源
        isr.close();

        //6.把读取到的数据返回
        return sb.toString();
    }
}

运行结果

Test2 – hutool-all-5.8.10.jar工具包的使用

import cn.hutool.core.io.FileUtil;
import cn.hutool.core.util.ReUtil;
import cn.hutool.http.HttpUtil;

import java.util.*;

public class Test2 {
    public static void main(String[] args) {
        /*
        利用糊涂包生成假数据，并写到文件当中

         制造假数据：
             获取姓氏：https://hanyu.baidu.com/shici/detail?pid=0b2f26d4c0ddb3ee693fdb1137ee1b0d&from=kg0
             获取男生名字：http://www.haoming8.cn/baobao/10881.html
             获取女生名字：http://www.haoming8.cn/baobao/7641.html
        */

        //1.定义变量用来记录网址
        String familyNameNet = "https://hanyu.baidu.com/shici/detail?pid=0b2f26d4c0ddb3ee693fdb1137ee1b0d&from=kg0";
        String boyNameNet = "http://www.haoming8.cn/baobao/10881.html";
        String girlNameNet = "http://www.haoming8.cn/baobao/7641.html";

        //2.爬取数据
        String familyNameStr = HttpUtil.get(familyNameNet);
        String boyNameStr = HttpUtil.get(boyNameNet);
        String girlNameStr = HttpUtil.get(girlNameNet);

        //3.利用正则表达式获取数据
        //通过正则表达式，把其中符合要求的数据获取出来
        List<String> familyNameTempList = ReUtil.findAll("(.{4})(，|。)", familyNameStr, 1);
        List<String> boyNameTempList = ReUtil.findAll("([\\u4E00-\\u9FA5]{2})(、|。)", boyNameStr, 1);
        List<String> girlNameTempList = ReUtil.findAll("(.. ){4}..", girlNameStr, 0);
        System.out.println("familyNameTempList = " + familyNameTempList);
        System.out.println("boyNameTempList = " + boyNameTempList);
        System.out.println("girlNameTempList = " + girlNameTempList);

        //4.处理数据
        //familyNameTempList（姓氏）
        //处理方案：把每一个姓氏拆开并添加到一个新的集合当中
        ArrayList<String> familyNameList = new ArrayList<>();
        for (String str : familyNameTempList) {
            // 赵钱孙李     周吴郑王    冯陈褚卫    蒋沈韩杨    朱秦尤许
            for (int i = 0; i < str.length(); i++) {
                char c = str.charAt(i);
                //System.out.println("c = " + c);
                familyNameList.add(c + "");
            }
        }
        System.out.println("familyNameList = " + familyNameList);

        //boyNameTempList（男生的名字）
        //处理方案：去除其中的重复方案
        ArrayList<String> boyNameList = new ArrayList<>();
        for (String str : boyNameTempList) {
            if (!boyNameList.contains(str)) {
                boyNameList.add(str);
            }
        }
        System.out.println("boyNameList = " + boyNameList);

        //girlNameTempList（女生的名字）
        //处理方案：把里面的每一个元素用空格进行切割，得到每一个女生的名字
        ArrayList<String> girlNameList = new ArrayList<>();
        for (String str : girlNameTempList) {
            String[] arr = str.split(" ");
            for (int i = 0; i < arr.length; i++) {
                girlNameList.add(arr[i]);
            }
        }
        System.out.println("girlNameList = " + girlNameList);

        //5.生成数据
        //姓名（唯一）-性别-年龄
        ArrayList<String> list = getInfos(familyNameList, boyNameList, girlNameList, 1300, 1400);
        Collections.shuffle(list);
        System.out.println("list = " + list);

        //6.写出数据
        //细节：
        //糊涂包的相对路径，不是相对于当前项目而言的，而是相对class文件而言的
        FileUtil.writeLines(list,"day28-myiotest\\file\\names.txt","UTF-8");
    }

    /**
     * 作用：获取男生和女生的信息：张三-男-23
     * <p>
     * 形参
     *
     * @param familyNameList 参数一：装着姓氏的集合
     * @param boyNameList    参数二：装着男生名字的集合
     * @param girlNameList   参数三：装着女生名字的集合
     * @param boyCount       参数四：男生的个数
     * @param girlCount      参数五：女生的个数
     * @return 返回字符串：张三-男-23
     */
    public static ArrayList<String> getInfos(ArrayList<String> familyNameList, ArrayList<String> boyNameList, ArrayList<String> girlNameList, int boyCount, int girlCount) {

        //1.生成男生不重复的名字  张三
        HashSet<String> boyHs = new HashSet<>();
        while (true) {
            if (boyHs.size() == boyCount) {
                break;
            }
            //随机
            Collections.shuffle(familyNameList);
            Collections.shuffle(boyNameList);
            boyHs.add(familyNameList.get(0) + boyNameList.get(0));
        }
        System.out.println("boyHs = " + boyHs);

        //2.生成女生不重复的名字  王二麻子
        HashSet<String> girlHs = new HashSet<>();
        while (true) {
            if (girlHs.size() == girlCount) {
                break;
            }
            //随机
            Collections.shuffle(familyNameList);
            Collections.shuffle(girlNameList);
            girlHs.add(familyNameList.get(0) + girlNameList.get(0));
        }
        System.out.println("girlHs = " + girlHs);

        //3. 赵鸿光-男-23
        //   赵亦曼-女-25
        ArrayList<String> list = new ArrayList<>();
        Random r = new Random();
        //【18 ~ 27】
        //-18  0~9
        //尾巴 + 1  9 + 1 = 10
        for (String boyName : boyHs) {
            // boyName依次表示每一个男生的名字
            int age = r.nextInt(10) + 18;
            list.add(boyName + "-男-" + age);
        }

        //4.生成女生的信息并添加到集合当中
        //【18 ~ 25】
        //-18 0~7
        //尾巴+1 7+1=8
        for (String girlName : girlHs) {
            // girlName依次表示每一个女生的名字
            int age = r.nextInt(8) + 18; //0 ~ 7 + 18 = 18~25
            list.add(girlName + "-女-" + age);
        }

        return list;
    }

}

运行结果

随机点名器

随机点名器1

allnames1.txt

姜和悦-女-19
阙志高-男-22
傅晋运-男-25
郦琪瑶-女-25
明绮灵-女-19
阳香梅-女-18
厍韵轩-男-24
詹仪婕-女-21
乌棋道-男-25
安佳凌-女-20
离棋道-男-26
劳泽曲-男-25
鲍梅英-女-20
祁林帆-女-19
贺桦振-男-19
仲时辰-男-27
平德向-男-25
颜慕娴-女-18
笪劲轩-男-21
官若环-女-19
费涛阳-男-20
漆博方-男-23
仇文帆-男-19
怀代秋-女-20
冶曼珍-女-20
贡慕妍-女-19
蓬月莹-女-25
佘杰冠-男-23
穆碧春-女-25
郈嘉霜-女-20
易芷云-女-23
台风涛-男-19
国彬新-男-24
羊冠浩-男-21

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Random;

public class Test {
    public static void main(String[] args) throws IOException {
         /*
            需求：
                有一个文件里面存储了班级同学的信息，每一个信息占一行。
                格式为：张三-男-23
                要求通过程序实现随机点名器。

            运行效果：
                第一次运行程序：随机同学姓名1（只显示名字）
                第二次运行程序：随机同学姓名2（只显示名字）
                第三次运行程序：随机同学姓名3（只显示名字）
                …
         */

        //1.读取文件中学生的姓名
        ArrayList<String> list = new ArrayList<>();
        BufferedReader br = new BufferedReader(new FileReader("day28-myiotest\\file\\allnames1.txt"));
        String line;
        while ((line = br.readLine()) != null) {
            list.add(line);
        }
        //释放资源
        br.close();

        //2.1.随机抽取(解法一)
        Random r = new Random();
        int index = r.nextInt(list.size());
        String randomName1 = list.get(index);
        String stu1 = randomName1.split("-")[0];
        System.out.println("stu1 = " + stu1);

        //2.2.随机抽取(解法二)
        Collections.shuffle(list);
        String stu2 = list.get(0).split("-")[0];
        System.out.println("stu2 = " + stu2);
    }
}

随机点名器2

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Random;

public class Test {
    public static void main(String[] args) throws IOException {
        /*
        需求:
            一个文件里面存储了班级同学的信息，每一个学生信息占一行。
            格式为：张三-男-23
            要求通过程序实现随机点名器。

        运行效果:
            70%的概率随机到男生
            30%的概率随机到女生
            总共随机100万次，统计结果。
            注意观察：看生成男生和女生的比例是不是接近于7：3
        */

        //1.读取数据，并把男生和女生的信息添加到不同的集合当中
        ArrayList<String> boyNameList = new ArrayList<>();
        ArrayList<String> girlNameList = new ArrayList<>();
        BufferedReader br = new BufferedReader(new FileReader("day28-myiotest\\file\\allnames1.txt"));
        String line;
        while ((line = br.readLine()) != null) {
            String sex = line.split("-")[1];
            if ("男".equals(sex)) {
                boyNameList.add(line);
            } else if ("女".equals(sex)) {
                girlNameList.add(line);
            }
        }
        //释放资源
        br.close();

        //2.定义权重集合，男女比例 7:3
        ArrayList<Integer> list = new ArrayList<>();
        Collections.addAll(list, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0);

        //3.定义变量，统计被点的个数
        int boyCount = 0;
        int girlCount = 0;
        Random r = new Random();

        //4.循环100万次
        for (int i = 0; i < 1000000; i++) {
            //5.从权重集合中获取随机数据
            int index = r.nextInt(list.size());
            int weight = list.get(index);

            //6.判断获取的随机数据是1还是0
            if (weight == 1) {
                //1就随机男生
                Collections.shuffle(boyNameList);
                String boyInfo = boyNameList.get(0);
                System.out.println("boyInfo = " + boyInfo);
                boyCount++;
            } else {
                //0就随机女生
                Collections.shuffle(girlNameList);
                String girlInfo = girlNameList.get(0);
                System.out.println("girlInfo = " + girlInfo);
                girlCount++;
            }
        }

        System.out.println("随机抽取100万次，其中男生被抽到了" + boyCount);
        System.out.println("随机抽取100万次，其中女生被抽到了" + girlCount);
        System.out.println(boyCount + girlCount);

    }
}

随机点名器3

import java.io.*;
import java.util.ArrayList;
import java.util.Collections;

public class Test {
    public static void main(String[] args) throws IOException {
        /*
              需求：
                一个文件里面存储了班级同学的姓名，每一个姓名占一行。
                要求通过程序实现随机点名器。
                第三次必定是张三同学

              运行效果：
                第一次运行程序：随机同学姓名1
                第二次运行程序：随机同学姓名2
                第三次运行程序：张三
                …
         */

        //1.读取数据，并把学生的信息添加到集合当中
        ArrayList<String> list = new ArrayList<>();
        BufferedReader br1 = new BufferedReader(new FileReader("day28-myiotest\\file\\allnames1.txt"));
        String line;
        while ((line = br1.readLine()) != null) {
            list.add(line);
        }
        //释放资源
        br1.close();

        //2.读取当前程序已经运行的次数
        BufferedReader br2 = new BufferedReader(new FileReader("day28-myiotest\\file\\count.txt"));
        String countStr = br2.readLine();
        int count = Integer.parseInt(countStr);
        System.out.println("count = " + count);
        //释放资源
        br2.close();

        //3.表示程序再次运行一次
        count++;
        System.out.println("count = " + count);

        //4.判断。如果当前已经是第三次，直接打印，不是第三次才随机
        if (count == 3) {
            System.out.println("张三");
        } else {
            Collections.shuffle(list);
            String stuInfo = list.get(0);
            String[] arr = stuInfo.split("-");
            String stuName = arr[0];
            System.out.println("stuName = " + stuName);
        }

        //5.将程序的运行次数写入本地文件
        BufferedWriter bw = new BufferedWriter(new FileWriter("day28-myiotest\\file\\count.txt"));
        bw.write(count + "");
        //释放资源
        bw.close();
    }
}

随机点名器4

	阴诗雁-女-25
	屈燕妮-女-24
	钦逸抒-女-21

import java.io.*;
import java.util.ArrayList;
import java.util.Collections;

public class Test {
    public static void main(String[] args) throws IOException {
        /*
        需求：
            一个文件里面存储了班级同学的姓名，每一个姓名占一行。
            要求通过程序实现随机点名器。

          运行结果：
            被点到的学生不会再被点到。
            但是如果班级中所有的学生都点完了， 需要自动的重新开启第二轮点名。
            细节1:假设班级有10个学生，每一轮中每一位学生只能被点到一次，程序运行10次，第一轮结束
            细节2:第11次运行的时候，我们自己不需要手动操作本地文件，要求程序自动开始第二轮点名

          核心思想：
               点一个删一个，把删除的备份，全部点完时还原数据。
        */

        //1.定义变量，表示初始文件路径，文件中存储所有的学生信息
        String src = "day28-myiotest\\file\\allnames.txt";

        //2.定义变量，表示备份文件，一开始文件为空
        String backups = "day28-myiotest\\file\\backups.txt";

        //3.读取初始文件中的数据，并把学生信息添加到集合当中
        ArrayList<String> list = readFile(src);

        //4.判断集合中是否有数据
        if (list.size() == 0) {
            //5.如果没有数据，表示学生已经点完，从backups.txt中还原数据即可
            //还原数据需要以下步骤：
            //5.1 读取备份文件中的所有数据
            list = readFile(backups);

            //5.2 把所有的数据写到初始文件中
            writeFile(src, list, false);

            //5.3 删除备份文件
            new File(backups).delete();
        }

        //5.集合中有数据，表示还没有点完，点一个删一个，把删除的备份到backups.txt当中
        //打乱集合
        Collections.shuffle(list);

        //获取0索引的学生信息并删除
        String stuInfo = list.remove(0);

        //打印随机到的学生信息
        System.out.println("被点到的学生信息为：" + stuInfo);

        //把删除之后的所有学生信息，写到初始文件中
        writeFile(src, list, false);

        //把删除的学生信息备份（追加写入）
        writeFile(backups, stuInfo, true);
    }

    /**
     * 把删除的学生信息备份（追加写入）
     *
     * @param pathFile 备份文件路径
     * @param stu      备份学生信息
     * @param isAppend 是否追加写入
     * @throws IOException 抛出异常
     */
    private static void writeFile(String pathFile, String stu, boolean isAppend) throws IOException {
        BufferedWriter bw = new BufferedWriter(new FileWriter(pathFile, isAppend));
        bw.write(stu);
        bw.newLine();
        bw.close();
    }

    /**
     * 把所有的数据写到初始文件中，还原数据
     *
     * @param pathFile 初始文件的路径
     * @param list     备份的学生集合
     * @param isAppend 是否在文件中追加数据，不追加表示重写
     * @throws IOException 抛出异常
     */
    private static void writeFile(String pathFile, ArrayList<String> list, boolean isAppend) throws IOException {
        BufferedWriter bw = new BufferedWriter(new FileWriter(pathFile, isAppend));
        for (String str : list) {
            bw.write(str);
            bw.newLine();
        }
        bw.close();
    }

    /**
     * 读取初始文件中的数据，并把学生信息添加到集合当中
     *
     * @param pathFile 初始文件的路径
     * @return 返回学生信息集合
     * @throws IOException 抛出异常
     */
    private static ArrayList<String> readFile(String pathFile) throws IOException {
        ArrayList<String> list = new ArrayList<>();
        BufferedReader br = new BufferedReader(new FileReader(pathFile));
        String line;
        while ((line = br.readLine()) != null) {
            list.add(line);
        }
        //释放资源
        br.close();
        return list;
    }
}

随机点名器5 【带权重的随机算法】

import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;

/*
钦逸抒-女-21-0.5
屈燕妮-女-24-1.0
阴诗雁-女-25-1.0
伯荷燕-女-24-1.0
欧文新-男-20-0.5
董泽欧-男-18-1.0
滕星磊-男-18-1.0
阚晴岚-女-22-1.0
傅彬远-男-19-1.0
左花依-女-24-0.25
 */
public class Test {
    public static void main(String[] args) throws IOException {
        /*
        TxT文件中事先准备好一些学生信息，每个学生的信息独占一行。
        要求1 : 每次被点到的学生，再次被点到的概率在原先的基础上降低一半。
        举例 : 80个学生，点名5次，每次都点到小A，概率变化情况如下 :
                第一次每人概率:1.25%。
                第二次小A概率 : 0.625%。     其他学生概率 : 1.2579%
                第三次小A概率 : 0.3125%。    其他学生概率 : 1.261867%
                第四次小A概率 : 0.15625%。   其他学生概率 : 1.2638449%
                第五次小A概率 : 0.078125%。  其他学生概率 : 1.26483386%
        提示 : 本题的核心就是带权重的随机算法
        提示 : 本题需要用到集合，IO，权重随机算法，有基础的同学可以试试，0基础的同学等 IO学完之后再做。
         */

        //1.把文件中所有的学生信息读取到内存中
        ArrayList<Student> stuList = new ArrayList<>();
        BufferedReader br = new BufferedReader(new FileReader("day28-myiotest\\file\\names6.txt"));
        String line;
        while ((line = br.readLine()) != null) {
            String[] arr = line.split("-");
            stuList.add(new Student(arr[0], arr[1], Integer.parseInt(arr[2]), Double.parseDouble(arr[3])));
        }
        //释放资源
        br.close();

        System.out.println("stuList = " + stuList);

        //2.计算权重的总和
        double weight = 0;
        for (Student stu : stuList) {
            weight += stu.getWeight();
        }
        System.out.println("weight = " + weight);

        //3.计算每一个人的实际占比
        double[] arr = new double[stuList.size()];
        int index1 = 0;
        for (Student stu : stuList) {
            arr[index1] = stu.getWeight() / weight;
            index1++;
        }
        System.out.println("Arrays.toString(arr) = " + Arrays.toString(arr));

        //4.计算每一个人的权重占比范围
        for (int i = 1; i < arr.length; i++) {
            arr[i] += arr[i - 1];
        }
        System.out.println("Arrays.toString(arr) = " + Arrays.toString(arr));

        //5.随机抽取
        //获取一个0.0~0.1之间的随机数
        double number = Math.random();
        System.out.println("number = " + number);
        //判断number在arr中的位置
        //二分查找法
        //方法回返回： - 插入点 - 1
        //获取number这个数据在数组当中的插入点位置
        int index2 = Arrays.binarySearch(arr, number);
        System.out.println("index2 = " + index2);
        int result = -Arrays.binarySearch(arr, number) - 1;
        System.out.println("result = " + result);
        Student stu = stuList.get(result);
        System.out.println("stu = " + stu);

        //6.修改当前学生的权重
        double w = stu.getWeight() / 2;
        stu.setWeight(w);
        System.out.println("stuList = " + stuList);

        //7.把集合中的数据再次写到文件中
        BufferedWriter bw = new BufferedWriter(new FileWriter("day28-myiotest\\file\\names6.txt"));
        for (Student student : stuList) {
            //bw.write(student.getName() + "-" + student.getGender() + "-" + student.getAge() + "-" + student.getWeight());
            bw.write(student.toLine());
            bw.newLine();
        }
        //释放资源
        bw.close();
    }
}

登录注册

写一个登陆小案例

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.Scanner;

public class Test {
    public static void main(String[] args) throws IOException {
        /*
            需求:写一个登陆小案例。

            步骤:
            将正确的用户名和密码手动保存在本地的userinfo.txt文件中。
            保存格式为:username=zhangsan&password=123
            让用户键盘录入用户名和密码
                比较用户录入的和正确的用户名密码是否一致
            如果一致则打印登陆成功
                如果不一致则打印登陆失败
         */

        //1.读取正确的用户名和密码
        BufferedReader br = new BufferedReader(new FileReader("day28-myiotest\\file\\userinfo.txt"));
        String line = br.readLine();//username=zhangsan&password=123
        br.close();

        System.out.println("line = " + line);

        String[] userInfo = line.split("&");
        String[] arr1 = userInfo[0].split("=");
        String[] arr2 = userInfo[1].split("=");

        String rightUserName = arr1[1];
        String rightPasswordName = arr2[1];
        System.out.println("rightUserName = " + rightUserName);
        System.out.println("rightPasswordName = " + rightPasswordName);

        //2.让用户键盘录入用户名和密码
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入用户名：");
        String username = sc.nextLine();
        System.out.println("请输入密码：");
        String password = sc.nextLine();

        //3.比较
        if (rightUserName.equals(username) && rightPasswordName.equals(password)) {
            System.out.println("登录成功！！！");
        } else {
            System.out.println("登录失败！！！");
        }

    }
}

写一个登陆小案例(添加锁定账户功能)

import java.io.*;
import java.util.Scanner;

public class Test {
    public static void main(String[] args) throws IOException {
        /*
            需求:写一个登陆小案例(添加锁定账户功能)。

            步骤:
            将正确的用户名和密码手动保存在本地的 userinfo2.txt文件中。
            保存格式为:username=zhangsan&password=123&count=0
            让用户键盘录入用户名和密码
                比较用户录入的和正确的用户名密码是否一致
            如果一致则打印登陆成功
                如果不一致则打印登陆失败,连续输三次被锁定
         */

        //1.读取正确的用户名和密码
        BufferedReader br = new BufferedReader(new FileReader("day28-myiotest\\file\\userinfo2.txt"));
        String line = br.readLine();//username=zhangsan&password=123&count=0
        br.close();

        System.out.println("line = " + line);

        String[] userInfo = line.split("&");
        String[] arr1 = userInfo[0].split("=");
        String[] arr2 = userInfo[1].split("=");
        String[] arr3 = userInfo[2].split("=");

        String rightUserName = arr1[1];
        String rightPasswordName = arr2[1];
        //count:表示用户连续输错的次数
        int rightCount = Integer.parseInt(arr3[1]);


        //2.让用户键盘录入用户名和密码
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入用户名：");
        String username = sc.nextLine();
        System.out.println("请输入密码：");
        String password = sc.nextLine();

        //3.比较
        if (rightUserName.equals(username) && rightPasswordName.equals(password) && rightCount < 3) {
            String content = "username=" + rightUserName + "&password=" + rightPasswordName + "&count=0";
            writeInfo(content);
            System.out.println("登录成功");
        } else if (rightCount == 3) {
            System.out.println("连续输错三次，账户被锁定。。。。");
        } else {
            System.out.println("登陆失败,还剩下" + (3 - rightCount) + "次机会");
            rightCount++;
            //写入
            BufferedWriter bw = new BufferedWriter(new FileWriter("day28-myiotest\\file\\userinfo2.txt"));
            String content = "username=" + rightUserName + "&password=" + rightPasswordName + "&count=" + rightCount;
            bw.write(content);
            bw.close();
            System.out.println("登录失败");
        }

    }
    
    /**
     * 作用：写出一个字符串到本地文件中
     *
     * @param content 参数：要写出的字符串
     * @throws IOException 异常
     */
    public static void writeInfo(String content) throws IOException {
        BufferedWriter bw = new BufferedWriter(new FileWriter("day28-myiotest\\file\\userinfo2.txt"));
        bw.write(content);
        bw.close();
    }
    
}

补全拼图小游戏的登录注册

给拼图小游戏的登录增加以下功能：密码连续输入3次，当前账号被锁定

游戏存档和读档

游戏配置

Properties的基本使用

• Test1

import java.util.Map;
import java.util.Properties;
import java.util.Set;

public class Test1 {
    public static void main(String[] args) {
        /*
            Properties作为Map集合的操作
         */

        //1.创建集合的对象
        Properties prop = new Properties();

        //2.添加数据
        // 细节：虽然我们可以往Properties当中添加任意的数据类型，但是一般只会往里面添加字符串类型的数据
        prop.put("aaa", "bbb");
        prop.put("aaa", "bbb");
        prop.put("ccc", "111");
        prop.put("ddd", "222");
        prop.put("eee", "bbb");

        //3.打印集合
        System.out.println("prop = " + prop);

        //4.遍历集合
        System.out.println("-----------------------------");
        Set<Object> keys = prop.keySet();
        for (Object key : keys) {
            Object value = prop.get(key);
            System.out.println(key + " : " + value);
        }

        System.out.println("-----------------------------");
        Set<Map.Entry<Object, Object>> entries = prop.entrySet();
        for (Map.Entry<Object, Object> entry : entries) {
            Object key = entry.getKey();
            Object value = entry.getValue();
            System.out.println(key + " : " + value);
        }

    }
}

import java.io.*;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

public class Test2 {
    public static void main(String[] args) throws IOException {
        /*
            Properties跟IO流结合的操作
         */

        //1.创建集合的对象
        Properties prop = new Properties();

        //2.添加数据
        prop.put("aaa", "bbb");
        prop.put("aaa", "bbb");
        prop.put("ccc", "111");
        prop.put("ddd", "222");
        prop.put("eee", "bbb");

        //3.把集合中的数据以键值对的形式写到本地文件当中
        FileOutputStream fos=new FileOutputStream(new File("day28-myiotest/file/b.properties"));
        prop.store(fos, "test");
        fos.close();

        /*BufferedWriter bw = new BufferedWriter(new FileWriter("day28-myiotest/file/a.properties"));
        Set<Map.Entry<Object, Object>> entries = prop.entrySet();
        for (Map.Entry<Object, Object> entry : entries) {
            Object key = entry.getKey();
            Object value = entry.getValue();
            bw.write(key + "=" + value);
            bw.newLine();
        }
        //释放资源
        bw.close();*/

    }
}

import java.io.FileInputStream;
import java.io.IOException;
import java.util.Properties;

public class Test3 {
    public static void main(String[] args) throws IOException {
        /*
            读取本地Properties文件里面的数据
         */

        //1.创建Properties集合对象
        Properties prop = new Properties();

        //2.读取本地Properties文件里面的数据
        FileInputStream fis = new FileInputStream("day28-myiotest/file/b.properties");
        prop.load(fis);
        fis.close();

        //3.打印集合
        System.out.println("prop = " + prop);
    }
}

文章来源地址https://www.toymoban.com/news/detail-544578.html

每日一记

到了这里，关于java基础入门-21-【阶段综合案例（带权重的随机&每日一记）】的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！