天天看点
返回

IO流——综合案例IO流综合案例

IO流综合案例

1. 集合到文件

  • 要求把集合中的元素写入指定文件中 
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;

//集合到文件
/*
1.创建一个字符缓冲输出流对象
2.创建一个ArrayList集合对象
3.添加元素
4.遍历集合
5.写入数据 一次写入一行
 */
public class Test01 {
    public static void main(String[] args) throws IOException {
        //创建字符缓冲输出流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("iodemo\\demo.txt"));
        //创建集合对象
        ArrayList<String> arr = new ArrayList<>();
        //添加元素
        arr.add("hello");
        arr.add("world");
        arr.add("java");
        //遍历集合
        for (String s : arr) {
            //写数据
            bw.write(s);
            //换行
            bw.newLine();
            bw.flush();
        }
        //释放资源
        bw.close();
    }
}

2. 文件到集合

  • 要求把文件中的内容写入集合中 
import java.io.*;
import java.util.ArrayList;

//文件到集合
/*
1.创建字符缓冲输入流对象
2.创建ArrayList集合
3.读取文件数据 一次读取一行
4.将读取的数据写入ArrayList集合中
5.遍历ArrayList集合
 */
public class Test02 {
    public static void main(String[] args) throws IOException {
        //创建字符缓冲输入流对象
        BufferedReader br = new BufferedReader(new FileReader("iodemo\\demo.txt"));
        //创建ArrayList集合对象
        ArrayList<String> arr = new ArrayList<>();
        //创建一个字符串 用于接收读取的数据
        String line;
        while ((line =br.readLine())!= null){
            //将数据写入集合
            arr.add(line);
        }
        //遍历集合
        for (String s : arr) {
            System.out.println(s);
        }
    }
}

3. 点名器 

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Random;
//点名器
/*
1.创建字符缓冲输入流对象
2.创建ArrayList集合对象
3.读取数据 存入集合
4.生成一个随机数 整型接收并且给定范围
5.通过随机数作为索引输出集合对应元素
 */
public class Test03 {
    public static void main(String[] args) throws IOException {
        //创建字符缓冲输入流对象
        BufferedReader br = new BufferedReader(new FileReader("iodemo\\dianming.txt"));
        //创建ArrayList集合对象
        ArrayList<String> arr = new ArrayList<>();
        //读数据
        String line;
        while ((line = br.readLine())!= null){
            //添加元素到集合
            arr.add(line);
        }
        //随机生成索引
        Random r = new Random();
        //范围为arr.size() 如果不给规定范围会导致异常 索引越界
        int index = r.nextInt(arr.size());
        //索引指定元素
        String name = arr.get(index);
        System.out.println("幸运选手：" + name);
    }
}

4. 集合到文件 （第2版）

  • 集合存储类型是学生类
  • 测试类 
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
//集合到文件 集合类型为 学生类
/*
1.定义学生类 
2.创建字符缓冲输出流对象
3.创建集合对象
4.创建学生对象
5.将学生对象添加到集合
6.遍历集合 得到的是学生对象
7.按要求拼接学生对象的信息 使用StringBuilder
8.写数据 一次写一行 这里注意把StringBuilder转为String类型写入
9.释放资源
 */
public class Test {
    public static void main(String[] args) throws IOException {
        //创建字符缓冲输出流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("iodemo\\student.txt"));
        //创建集合对象
        ArrayList<Student> arr = new ArrayList<>();
        //创建学生对象
        Student s1 = new Student("11111", "张三", 18);
        Student s2 = new Student("22222", "李四", 19);
        Student s3 = new Student("33333", "王五", 20);
        //将学生对象添加到集合
        arr.add(s1);
        arr.add(s2);
        arr.add(s3);
        //遍历集合 得到的是学生对象
        for (Student st : arr) {
            StringBuilder sb = new StringBuilder();
            sb.append(st.getSid()).append(",").append(st.getName()).append(",").append(st.getAge());
            //写数据
            bw.write(sb.toString());
            //换行
            bw.newLine();
            //刷新
            bw.flush();
        }
        //释放资源
        bw.close();
    }
}
  • 学生类 
public class Student {
    private String sid;
    private String name;
    private int age;

    public Student() {
    }

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

    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;
    }
}

5. 文件到集合（第2版）

  • 集合存储类型为学生类
  • 测试类 
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
//文件到集合 第2版
/*
1.定义学生类
2.创建ArrayList集合对象
3.创建字符缓冲输入流对象
4.读取数据 一次读一行
5.使用split();方法对读取到的字符串进行切片
6.创建学生对象并set值
7.将学生对象添加到集合
8.释放资源
9.遍历集合
 */
public class Test02 {
    public static void main(String[] args) throws IOException {
        //创建集合对象
        ArrayList<Student> arr = new ArrayList<>();
        //创建字符缓冲输入流对象
        BufferedReader br = new BufferedReader(new FileReader("iodemo\\student.txt"));
        //读数据
        String line;
        while ((line = br.readLine()) != null){
            //split();方法 切片
            String[] strarr = line.split(",");
            //创建学生对象
            Student s = new Student();
            s.setSid(strarr[0]);
            s.setName(strarr[1]);
            s.setAge(Integer.parseInt(strarr[2]));
            //将学生对象添加到集合
            arr.add(s);
        }
        //释放资源
        br.close();
        //遍历集合
        for (Student s : arr) {
            System.out.println(s.getSid() + "," + s.getName() + "," + s.getAge());
        }
    }
}
  • 学生类 
public class Student {
    private String sid;
    private String name;
    private int age;

    public Student() {
    }

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

    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;
    }
}

6. 集合到文件 （数据排序版）

  • 采用键盘录入信息
  • 写入文件的数据按要求排序
  • 测试类 
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Comparator;
import java.util.Scanner;
import java.util.TreeSet;
//集合到文件数据排序 （第3版）
/*
1. 定义学生类
2. 创建TreeSet集合，通过比较器排序进行排序
3. 键盘录入学生数据
4. 创建学生对象，把键盘录入的数据对应赋值给学生对象的成员变量
5. 把学生对象添加到TreeSet集合
6. 创建字符缓冲输出流对象
7. 遍历集合，得到每一个学生对象
8. 把学生对象的数据拼接成指定格式的字符串
9. 调用字符缓冲输出流对象的方法写数据
10. 释放资源
 */
public class Test {
    public static void main(String[] args) throws IOException {
        BufferedWriter bw = new BufferedWriter(new FileWriter("iodemo\\demo.txt"));
        TreeSet<Student> ts = new TreeSet<>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                int num = s1.getsum()-s2.getsum();
                int num1 = num == 0 ? s1.getMath()- s2.getMath(): num;
                int num2 = num1 == 0 ? s1.getChinese() - s2.getChinese(): num1;
                int num3 = num2 == 0 ? s2.getName().compareTo(s1.getName()) : num1;
                return num3;
            }
        });

        for (int i = 0; i < 3; i++) {
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入姓名");
            String name = sc.nextLine();
            System.out.println("请输入数学成绩");
            int math = sc.nextInt();
            System.out.println("请输入语文成绩");
            int chinese = sc.nextInt();
            System.out.println("请输入英语成绩");
            int english = sc.nextInt();

            Student s = new Student();
            s.setName(name);
            s.setMath(math);
            s.setChinese(chinese);
            s.setEnglish(english);

            ts.add(s);
        }
        for (Student t : ts) {
            StringBuilder sb = new StringBuilder();
            sb.append(t.getName()).append(",").append(t.getMath()).append(",").append(t.getChinese()).append(",").append(t.getEnglish()).append(",").append(t.getsum());
            bw.write(sb.toString());
            bw.newLine();
            bw.flush();
        }
        bw.close();
    }
}
  • 学生类 
public class Student {
    private String name;
    private int math;
    private int chinese;
    private int english;

    public Student() {
    }

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

    public String getName() {
        return name;
    }

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

    public int getMath() {
        return math;
    }

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

    public int getChinese() {
        return chinese;
    }

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

    public int getEnglish() {
        return english;
    }

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

    public int getsum(){
        int sum = this.math + this.chinese + this.english;
        return sum;
    }
}

7. 复制单级文件夹

  • 复制单级文件夹到指定目录下
  • 复制这个文件夹包括文件夹里的文件 
import java.io.*;
//复制单级文件夹
/*
1. 创建数据源目录File对象，路径是E:\Java_test\java
2. 获取数据源目录File对象的名称
3. 创建目的地目录File对象，路径由(模块名+第2步获取的名称)组成
4. 判断第3步创建的File是否存在，如果不存在，就创建
5. 获取数据源目录下所有文件的File数组
6. 遍历File数组，得到每一个File对象，该File对象，其实就是数据源文件
7. 获取数据源文件File对象的名称
8. 创建目的地文件File对象，路径由(目的地目录+第7步获取的名称)组成
9. 复制文件
    由于不清楚数据源目录下的文件都是什么类型的，所以采用字节流复制文件
    采用参数为File的构造方法
 */
public class test05 {
    public static void main(String[] args) throws IOException{
        //创建File对象
        File srcFolder = new File("E:\\Java_test\\java");
        //获取数据源目录名称
        String srcFolderName = srcFolder.getName();
        //创建目的地目录File对象
        File destFolder = new File("E:\\java_test_copy",srcFolderName);
        //判断创建的File是否存在，如果不存在，就创建
        if (!destFolder.exists()){
            destFolder.mkdir();
        }
        //获取数据源目录下所有文件的File数组
        File[] listFiles = srcFolder.listFiles();
        //遍历File数组，得到每一个File对象，该File对象，其实就是数据源文件
        for (File listFile : listFiles) {
            //获取数据源文件File对象的名称
            String listFileName = listFile.getName();
            //创建目的地文件File对象，路径由(目的地目录+获取的名称)组成
            File destFile = new File(destFolder,listFileName);
            //调用复制方法
            copy(listFile,destFile);
        }
    }
    //复制方法
    private static void copy(File listFile, File destFile) throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(listFile));
        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);
        }
        //释放资源
        bis.close();
        bos.close();
    }
}

8. 复制多级文件夹

  • 复制多级文件夹到指定目录下
  • 复制文件夹以及文件夹里的内容，文件夹里可能包含文件夹
  • 采用递归复制多级文件夹 
import java.io.*;
//复制多级文件
/*
1. 创建数据源File对象，路径是E:\\Java_test
2. 创建目的地File对象，路径是E:\\java_test_copy
3. 写方法实现文件夹的复制，参数为数据源File对象和目的地File对象
4. 判断数据源File是否是文件
   是文件：直接复制，用字节流
   不是文件：
      在目的地下创建该目录
      遍历获取该目录下的所有文件的File数组，得到每一个File对象
      回到3继续(递归)
 */
public class Test02 {
    public static void main(String[] args) throws IOException{
        File srcFile = new File("E:\\Java_test");
        File destFile = new File("E:\\java_test_copy");
        copyFolder(srcFile,destFile);

    }
    //复制文件夹
    private static void copyFolder(File srcFile,File destFile) throws IOException {
        //判断是否为文件夹
        if (srcFile.isDirectory()){
            //获取数据源目录名称
            String srcFileName = srcFile.getName();
            File newFolder = new File(destFile,srcFileName);
            //判断目录是否存在
            if (!newFolder.exists()){
                newFolder.mkdir();
            }
            File[] fileArray = srcFile.listFiles();
            for (File file : fileArray) {
                //采用递归调用
                copyFolder(file,newFolder);
            }
        }else {
            File newFile = new File(destFile,srcFile.getName());
            //调用复制文件方法
            copyFile(srcFile,newFile);

        }
    }
    //复制文件
    private static void copyFile(File srcFile, File newFile) throws IOException {
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(newFile));
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile));

        byte[] bys = new byte[1024];
        int len;
        while ((len = bis.read(bys))!=-1){
            bos.write(bys,0,len);
        }
        bos.close();
        bis.close();
    }
}
IO流 java intellij-idea
上一篇: IO流复习总结（三） 字符流、编码表
下一篇: IO流 综合应用-文件夹复制思路

继续阅读