同步练习(Java SE(九))补充

案例一:

需求: 把ArrayList集合中的字符串数据写入到文本文件。

要求: 每一个字符串元素作为文件中的一行数据

思路: 1.创建ArrayList集合

2.往集合中存储字符串元素

3.创建字符缓冲输出对象

4.遍历集合，得到每一个字符串数据

5.调用字符缓冲输出流对象的方法写数据

6.释放资源

package test;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;

public class Test75 {
    public static void main(String[] args) throws IOException {
        // 1.创建ArrayList集合
        ArrayList<String> al = new ArrayList<String>();
        // 2.往集合中存储字符串元素
        al.add("Hello");
        al.add("world");
        al.add("java");
        // 3.创建字符缓冲输出对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("myCharStream\\array.txt"));
        // 4.遍历集合，得到每一个字符串数据
        for (String str : al){
            // 5.调用字符缓冲输出流对象的方法写数据
            bw.write(str);
            bw.newLine();
            bw.flush();
        }
        // 6.释放资源
        bw.close();
    }
}

案例二: 文件到集合

需求: 把文本文件中的数据读到集合中，并遍历集合。

要求: 文件中每一行数据是一个集合元素

思路: 1.创建字符缓冲流对象

2.创建ArrayList集合对象

3.调用字符缓冲输入流对象的方法读数据

4.把读取到的字符串数据存储到集合中

5.释放资源

6.遍历集合

package test;

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

public class Test76 {
    public static void main(String[] args) throws IOException {
        // 1.创建字符缓冲流对象
        BufferedReader br = new BufferedReader(new FileReader("myCharStream\\array.txt"));
        // 2.创建ArrayList集合对象
        ArrayList<String> al = new ArrayList<String>();
        // 3.调用字符缓冲输入流对象的方法读数据
        String line;
        while ((line = br.readLine()) != null){
            // 4.把读取到的字符串数据存储到集合中
            al.add(line);
        }
        // 5.释放资源
        br.close();
        // 6.遍历集合
        for (String str : al){
            System.out.println(str);
        }
    }
}

案例三: 点名器

需求: 我有一个文件里面存储了班级同学的姓名，每一个姓名占一行，要求通过程序实现随机点名器

思路: 1.创建字符缓冲输入流对象

2.创建ArrayList结合对象

3.调用字符缓冲输入流对象的方法读数据

4.把读取的字符串数据存储到集合中

5.释放资源

6.使用Random产生一个随机数,随机数的范围在: [0,集合的长度)

7.把第6步产生的对技术作为索引到ArrayList集合中获取值

8.把第7步的得到的数据输出在控制台

package test;

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

public class Test77 {
    public static void main(String[] args) throws IOException {
        // 1.创建字符缓冲输入流对象
        BufferedReader br = new BufferedReader(new FileReader("myCharStream\\names.txt"));
        // 2.创建ArrayList结合对象
        ArrayList<String> al = new ArrayList<String>();
        // 3.调用字符缓冲输入流对象的方法读数据
        String line;
        while ((line = br.readLine()) != null){
            // 4.把读取的字符串数据存储到集合中
            al.add(line);
        }
        // 5.释放资源
        br.close();
        // 6.使用Random产生一个随机数,随机数的范围在: [0,集合的长度)
        Random r = new Random();
        int index = r.nextInt(al.size());
        // 7.把第6步产生的随机数作为索引到ArrayList集合中获取值
        String name = al.get(index);
        // 8.把第7步的得到的数据输出在控制台
        System.out.println("幸运者为:"+name);
    }
}

案例四: 集合到文件(改进版)

需求: 把ArrayList集合中的学生写入到文本文件。

要求: 每一个学生对象的数据作为文件中的一行数据

格式: 学号,姓名,年龄,居住地

思路: 1.定义学生类

2.创建ArrayList集合

3.创建学生对象

4.把学生对象添加到集合中

5.创建字符缓冲输出流对象

6.遍历集合，得到每一个学生对象

7.把学生对象的数据拼接成指定格式的字符串

8.调用字符缓冲输出流对象的方法写数据

9.释放资源

学生类

package test.test78;

// 1.定义学生类
public class Student {
    private String sid;
    private String name;
    private int age;
    private String address;

    public Student() {
    }

    public Student(String sid, String name, int age, String address) {
        this.sid = sid;
        this.name = name;
        this.age = age;
        this.address = address;
    }

    public String getSid() {
        return sid;
    }

    public void setSid(String sid) {
        this.sid = sid;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

测试类

package test.test78;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;

public class ArrayListToFileDemo {
    public static void main(String[] args) throws IOException {
        // 2.创建ArrayList集合
        ArrayList<Student> al = new ArrayList<Student>();
        // 3.创建学生对象
        Student s1 = new Student("001","张三",30,"西安");
        Student s2 = new Student("002","李四",35,"武汉");
        Student s3 = new Student("003","王五",33,"郑州");
        // 4.把学生对象添加到集合中
        al.add(s1);
        al.add(s2);
        al.add(s3);
        // 5.创建字符缓冲输出流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("myCharStream\\Student.txt"));
        // 6.遍历集合，得到每一个学生对象
        for (Student s : al){
            // 7.把学生对象的数据拼接成指定格式的字符串
            StringBuilder sb = new StringBuilder();
            sb.append(s.getSid()).append(",").append(s.getName()).append(",").append(s.getAge()).append(",").append(s.getAddress());
            // 8.调用字符缓冲输出流对象的方法写数据
            bw.write(sb.toString());
            bw.newLine();
            bw.flush();
        }
        // 9.释放资源
        bw.close();
    }
}

案例五: 文件到集合(改进版)

需求: 把文本文件中的数据读取到集合中，并遍历集合。

要求: 文件中每一行数据是一个学生对象的成员变量的变量值

思路: 1.定义学生类

2.创建字符缓冲输入流

3.创建ArrayList集合对象

4.调用字符缓冲输入流对象的方法读数据

5.把读取到的字符串数据用split()进行分割，得到一个字符串数组

6.创建学生对象

7.把字符串数组中的每一个元素取出来对应的赋值给学生对象的成员变量值

8.把学生对象添加到集合

9.释放资源

10.遍历集合

学生类

package test.test79;

// 1.定义学生类
public class Student {
    private String sid;
    private String name;
    private int age;
    private String address;

    public Student() {
    }

    public Student(String sid, String name, int age, String address) {
        this.sid = sid;
        this.name = name;
        this.age = age;
        this.address = address;
    }

    public String getSid() {
        return sid;
    }

    public void setSid(String sid) {
        this.sid = sid;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

测试类

package test.test79;

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

public class FileToArrayListDemo {
    public static void main(String[] args) throws IOException {
        // 2.创建字符缓冲输入流
        BufferedReader br = new BufferedReader(new FileReader("myCharStream\\students.txt"));
        // 3.创建ArrayList集合对象
        ArrayList<Student> al = new ArrayList<Student>();
        // 4.调用字符缓冲输入流对象的方法读数据
        String line;
        while ((line = br.readLine()) != null){
            // 5.把读取到的字符串数据用split()进行分割，得到一个字符串数组
            String[] strArray = line.split(",");
            // 6.创建学生对象
            Student s = new Student();
            // 7.把字符串数组中的每一个元素取出来对应的赋值给学生对象的成员变量值
            s.setSid(strArray[0]);
            s.setName(strArray[1]);
            s.setAge(Integer.parseInt(strArray[2]));
            s.setAddress(strArray[3]);
            // 8.把学生对象添加到集合
            al.add(s);
        }
        // 9.释放资源
        br.close();
        // 10.遍历集合
        for (Student s : al){
            System.out.println(s.getSid()+","+s.getName()+","+s.getAge()+","+s.getAddress());
        }
    }
}

案例六: 集合到文件(数据排序改进版)

需求: 键盘录入5个学生信息(姓名，语文成绩，数学成绩，英语成绩)。要求按照成绩总分从高到低写入文本文件

格式: 姓名,语文成绩，数学成绩，英语成绩

举例: 张三，98,99,100

思路: 1.定义学生类

2.创建TreeSet集合，通过比较器排序进行排序

3.键盘录入学生数据

4.创建学生对象，把键盘录入

5.把学生对象添加到TreeSet集合

6.创建字符缓冲输出流对象

7.遍历集合，得到每一个学生对象

8.把学生对象的数据拼接成指定格式的字符串

9.调用字符缓冲输出流对象的方法写数据

10.释放资源

学生类

package test.test80;

// 1.定义学生类
public class Student {
    private String name;
    private int chinese;
    private int math;
    private int english;

    public Student() {
    }

    public Student(String name, int chinese, int math, int english) {
        this.name = name;
        this.chinese = chinese;
        this.math = math;
        this.english = english;
    }

    public String getName() {
        return name;
    }

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

    public int getChinese() {
        return chinese;
    }

    public void setChinese(int chinese) {
        this.chinese = chinese;
    }

    public int getMath() {
        return math;
    }

    public void setMath(int math) {
        this.math = math;
    }

    public int getEnglish() {
        return english;
    }

    public void setEnglish(int english) {
        this.english = english;
    }

    public int getSum(){
        return this.chinese + this.math + this.english;
    }
}

测试类

package test.test80;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Comparator;
import java.util.Scanner;
import java.util.TreeSet;

public class TreeSetToFileDemo {
    public static void main(String[] args) throws IOException {
        // 2.创建TreeSet集合，通过比较器排序进行排序
        TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                // 成绩总分从高到低
                int num = s2.getSum() - s1.getSum();
                // 次要条件
                int num2 = num == 0 ? s1.getChinese() - s2.getChinese() : num;
                int num3 = num2 == 0 ? s1.getMath() - s2.getMath() : num;
                int num4 = num3 == 0 ? s1.getName().compareTo(s2.getName()) : num3;
                return num4;
            }
        });
        // 3.键盘录入学生数据
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < 5; i++){
            System.out.println("请输入第"+(i+1)+"个学生信息:");
            System.out.println("姓名:");
            String name = sc.nextLine();
            System.out.println("语文成绩:");
            int chinese = sc.nextInt();
            System.out.println("数学成绩:");
            int math = sc.nextInt();
            System.out.println("英语成绩");
            int english = sc.nextInt();
            // 4.创建学生对象，把键盘录入
            Student s = new Student(name,chinese,math,english);
            // 5.把学生对象添加到TreeSet集合
            ts.add(s);
        }
        // 6.创建字符缓冲输出流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("myCharStrram\\ts.txt"));
        // 7.遍历集合，得到每一个学生对象
        for (Student s : ts){
            // 8.把学生对象的数据拼接成指定格式的字符串
            StringBuilder sb = new StringBuilder();
            sb.append(s.getName()).append(",").append(s.getChinese()).append(",").append(s.getMath()).append(",").append(s.getEnglish());
            bw.write(sb.toString());
            bw.newLine();
            bw.flush();
        }
        // 10.释放资源
        bw.close();
    }
}

案例七: 复制单级文件夹

需求: 把"E:\\itcast"这个文件夹复制到模块目录下

思路: 1.创建数据源目录File对象，路径是E:\\itcast

2.获取数据源目录File对象的名称(itcast)

3.创建目的地目录File对象，路径名是模块名+itcast组成(myCharStream\\itcast)

4.判断目的地目录对应的File是否存在，如果不存在，就创建

5.获取数据源目录下所有文件的File数组

6.遍历File数组，得到每一个File对象，该File对象，其实就是数据源文件

数据源文件: E:\\itcast\\mn.jpg

7.获取数据源文件File对象的名称(mn.jpg)

8.创建目的地文件File对象，路径名是目的地目录+mn.jpg组成(myCharStream\\itcast\\mn.jpg)

9.复制文件

由于文件不仅仅是文本文件，还有图片，视频等文件，所以采用字节流复制文件

package test;

import java.io.*;

public class Test81 {
    public static void main(String[] args) throws IOException {
        // 1.创建数据源目录File对象，路径是E:\\itcast
        File srcFolder = new File("E:\\itcast");
        // 2.获取 数据源目录File对象的名称(itcast)
        String srcFoldername = srcFolder.getName();
        // 3.创建目的地目录File对象，路径名是模块名+itcast组成(myCharStream\\itcast)
        File destFolder = new File("myCharStream",srcFoldername);
        // 4.判断目的地目录对应的File是否存在，如果不存在，就创建
        if (!destFolder.exists()){
            destFolder.mkdir();
        }
        // 5.获取数据源目录下所有文件的File数组
        File[] listFiles = srcFolder.listFiles();
        // 6.遍历File数组，得到每一个File对象，该File对象，其实就是数据源文件
        for (File srcFile : listFiles){
            // 数据源文件: E:\\itcast\\mn.jpg
            // 7.获取数据源文件File对象的名称(mn.jpg)
            String srcFileName = srcFile.getName();
            // 8.创建目的地文件File对象，路径名是目的地目录+mn.jpg组成(myCharStream\\itcast\\mn.jpg)
            File destFile = new File(destFolder,srcFileName);
            // 9.复制文件
            copyFile(srcFile,destFile);
        }
    }

    // 9.复制文件
    // 由于文件不仅仅是文本文件，还有图片，视频等文件，所以采用字节流复制文件
    private static void copyFile(File srcFile, File destFile) throws IOException{
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFile));
        
        byte[] bys = new byte[1024];
        int len;
        while ((len = bis.read(bys)) != -1){
            bos.write(bys,0,len);
        }
        bos.close();
        bis.close();
    }
}

案例八: 复制多级文件夹

需求: 把"E:\\itcast"复制到F盘目录下

思路: 1.创建数据源File对象，路径是E:\\itcast

2.创建目的地File对象，路径是F:\\

3.写方法实现文件夹的复制，参数为数据源File对象和目的地File对象

4.判断数据源File是否是目录

是:

A: 在目的地下创建和数据源File对象名称一样的目录

B: 获取数据源File下所有文件或者目录的File数组

C: 遍历File数组，得到每一个FIle对象

D: 把该File作为数据源File对象，递归调用复制文件夹的方法

不是: 说明是文件，直接复制，用字节流

package test;

import java.io.*;

public class Test82 {
    public static void main(String[] args) throws IOException{
        //1.创建数据源File对象，路径是E:\\itcast
        File srcFile = new File("E:\\itcast");
        // 2.创建目的地File对象，路径是F:\\
        File destFIle = new File("F:\\");
        // 3.写方法实现文件夹的复制，参数为数据源File对象和目的地File对象
        copyFolder(srcFile,destFIle);
        
    }

    // 3.写方法实现文件夹的复制，参数为数据源File对象和目的地File对象
    private static void copyFolder(File srcFile, File destFIle) throws IOException{
        // 4.判断数据源File是否是目录
        if (srcFile.isDirectory()){
            // 是:
            // A: 在目的地下创建和数据源File对象名称一样的目录
            String srcFileName = srcFile.getName();
            File newFolder = new File(destFIle,srcFileName);
            if (newFolder.exists()){
                newFolder.createNewFile();
            }
            // B: 获取数据源File下所有文件或者目录的File数组
            File[] fileArray = srcFile.listFiles();
            // C: 遍历File数组，得到每一个FIle对象
            for (File file : fileArray){
                // D: 把该File作为数据源File对象，递归调用复制文件夹的方法
                copyFolder(file,newFolder);
            }
        }else {
            // 不是: 说明是文件，直接复制，用字节流
            File newFile = new File(destFIle,srcFile.getName());
            copyFile(srcFile,newFile);
        }
    }

    // 字节缓冲流复制文件
    private static void copyFile(File srcFile, File destFile) throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFile));

        byte[] bys = new byte[1024];
        int len;
        while ((len = bis.read(bys)) != -1){
            bos.write(bys,0,len);
        }
        bos.close();
        bis.close();
    }
}

案例九: 复制Java文件(打印流改进版)

需求: 把模块目录下的PrintStreamDemo.java复制到模块目录下的Copy.java

思路: 1.根据数据源创建字符输入流对象

2.根据目的地创建字符输出流对象

3.读写数据，复制文件

4.释放资源

package test;

import java.io.*;

public class Test83 {
    public static void main(String[] args) throws IOException {
        // 1.根据数据源创建字符输入流对象
        BufferedReader br = new BufferedReader(new FileReader("myOtherStream\\printStreamDemo.java"));
        // 2.根据目的地创建字符输出流对象
        PrintWriter pw = new PrintWriter(new FileWriter("myOtherStream\\Copy.java",true));
        // 3.读写数据，复制文件
        String line;
        while ((line = br.readLine()) != null){
            pw.println(line);
        }
        // 4.释放资源
        pw.close();
        br.close();
    }
}

案例十: 游戏次数

需求: 倾斜程序实现猜数字小游戏只能试玩3次,如果还想玩,提示: 游戏试玩已结束，想玩请充值

思路: 1.写一个游戏类，里面有一个猜数字的游戏

2.写一个测试类,测试类中有main()方法，main()方法中按照下面步骤完成:

A: 从文件中读取数据到Properties集合，用load()方法实现

文件已经存在: game.txt

里面有一个数据值: count=0

B: 通过Properties集合获取到玩游戏的次数

C: 判断次数是否到3次

如果到了，给出提示: 游戏试玩结束，想玩请充值

如果不到3次:

玩游戏

次数+1，重新写回文件，用Properties的store()方法实现

游戏类

package test.test84;

import java.util.Random;
import java.util.Scanner;

// 1.写一个游戏类，里面有一个猜数字的游戏
public class GuessNumber {
    public GuessNumber() {
    }

    public static void start(){
        // 要完成猜数字的游戏，首先需要有一个要猜的数字，使用随机数生成该数字，范围1到100
        Random r = new Random();
        int number = r.nextInt(100)+1;

        while (true){
            // 使用程序实现猜数字，每次均要输入一个猜测的数字值，需要使用键盘录入实现
            Scanner sc = new Scanner(System.in);

            System.out.println("请输入你要猜的数字");
            int guessNumber = sc.nextInt();

            // 比较水的数字和系统产生的数据，需要使用分支语句。这里使用if...else...if...格式，根据不同的情况进行猜测结果显示
            if (guessNumber > number){
                System.out.println("你猜的数字" + guessNumber + "大了");
            }else if (guessNumber < number){
                System.out.println("你猜的数字" + guessNumber + "小了");
            }else{
                System.out.println("恭喜你猜中了");
                break;
            }
        }
    }
}

测试类

package test.test84;

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

// 2.写一个测试类,测试类中有main()方法，main()方法中按照下面步骤完成:
public class PropertiesDemo {
    public static void main(String[] args) throws IOException {
        // A: 从文件中读取数据到Properties集合，用load()方法实现
        // 文件已经存在: game.txt
        // 里面有一个数据值: count=0
        Properties prop = new Properties();
        FileReader fr = new FileReader("myOtherStream\\game.txt");
        prop.load(fr);
        fr.close();

        // B: 通过Properties集合获取到玩游戏的次数
        String count = prop.getProperty("count");
        int number = Integer.parseInt(count);
        // C: 判断次数是否到3次
        if (number >= 3){
            // 如果到了，给出提示: 游戏试玩结束，想玩请充值
            System.out.println("游戏试玩结束，想玩请充值");
        }else {
            // 如果不到3次:
            // 玩游戏
            GuessNumber.start();
            // 次数+1，重新写回文件，用Properties的store()方法实现
            number++;
            prop.setProperty("count",String.valueOf(number));
        }
    }
}

原文链接：https://blog.csdn.net/weixin_52993606/article/details/121418099