IO流案例

1.集合到文件：

1）创建ArrayList集合
2）往集合中存储字符串元素
3）创建字符缓冲输出流对象
4）遍历集合，得到每一个字符串数据
5）调用字符缓冲输出流对象的方法写数据
6）释放资源

package Characters;

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

public class ArrayListToTxt {
    public static void main(String[] args) throws IOException {
        ArrayList<String> list = new ArrayList<>();

        list.add("hello");
        list.add("world");
        list.add("while");

        BufferedWriter writer = new BufferedWriter(new FileWriter("src\\Characters\\array.txt"));

        for(String s : list){
            writer.write(s);
            writer.newLine();
            writer.flush();
        }
        writer.close();

    }
}

2.文件到集合：

1）创建字符缓冲输入流对象
2）创建ArrayList集合对象
3）调用字符缓冲输入流对象的方法读数据
4）把读取到的字符串数据存储到集合中
5）释放资源
6）遍历集合

package Characters;

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

public class TxtToArrayList {
    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new FileReader("src\\Characters\\array.txt"));
        ArrayList<String> list = new ArrayList<>();

        String line;
        while((line = reader.readLine()) != null){
            list.add(line);
        }
        reader.close();

        for(String s : list){
            System.out.println(s);
        }
    }
}

3.点名器：

需求：文件里存储了班级同学的姓名，每个姓名占一行，要求通过程序实现随机点名器
1）创建字符缓冲输入流对象
2）创建ArrayList集合对象
3）调用字符缓冲输入流对象的方法读数据
4）把读取到的字符串数据存储到集合中
5）释放资源
6）使用Random产生一个随机数，随机数的范围在：[0,集合长度)
7）把第6步产生的随机数作为索引到ArrayList集合中获取值
8）输出第7步得到的值

package Characters;

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

public class CallName {
    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new FileReader("src\\Characters\\names.txt"));
        ArrayList<String> list = new ArrayList<>();

        String line;
        while((line = reader.readLine()) != null){
            list.add(line);
        }

        reader.close();

        int index;
        index = new Random().nextInt(list.size());

        String name = list.get(index);

        System.out.println(name);
    }
}

4.集合到文件（改进版）

需求：把ArrayList集合中的书生数据写入到文本文件。要求：每个学生对象的数据作为文件中的一行数据
1）定义学生类
2）创建ArrayList集合
3）创建学生对象
4）把学生对象添加到集合中
5）创建字符缓冲输出流对象
6）遍历集合，得到每一个学生对象
7）把学生对象的数据拼接成指定格式的字符串
8）调用字符缓冲输出流对象的方法写数据
9）释放资源

学生类1：

package Characters;

public class Student1 {
    private String sid;
    private String name;
    private int age;
    private String address;

    public Student1() {
    }

    public Student1(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 Characters;

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

public class ArrayListToFile {
    public static void main(String[] args) throws IOException {
        ArrayList<Student1> list = new ArrayList<>();

        Student1 s1 = new Student1("001","张三",28,"西安");
        Student1 s2 = new Student1("002","李四",21,"榆林");
        Student1 s3 = new Student1("003","王五",12,"宝鸡");
        Student1 s4 = new Student1("004","王麻子",45,"银川");

        list.add(s1);
        list.add(s2);
        list.add(s3);
        list.add(s4);

        BufferedWriter writer = new BufferedWriter(new FileWriter("src\\Characters\\student1"));

        for(Student1 st : list){
            StringBuilder sb = new StringBuilder();
            sb.append(st.getSid()).append(",").append(st.getName()).append(",").append(st.getAge()).append(",").append(st.getAddress());
            writer.write(sb.toString());
            writer.newLine();
            writer.flush();
        }
        writer.close();
    }
}

5.文件到集合（改进版）

需求：把文件中的数据读取到集合中。要求：文件中每一行数据是一个学生对象的成员变量值
1）定义学生类（同上）
2）创建字符缓冲输入流对象
3）创建ArrayList集合对象
4）调用字符缓冲输入流对象的方法读数据
5）把读取到的字符串数据用split()进行分割，得到一个字符串数组
6）创建学生对象
7）把字符串数组中的每一个元素取出来对应的赋值给学生对象的成员变量值
8）把学生对象添加到集合
9）释放资源
10）遍历集合

package Characters;

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

public class FileToArrayList {
    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new FileReader("src\\Characters\\student1"));
        ArrayList<Student1> list = new ArrayList<>();

        String line;
        while ((line = reader.readLine()) != null) {
            String[] s = line.split(",");
            Student1 st = new Student1(s[0], s[1], Integer.valueOf(s[2]), s[3]);
            list.add(st);
        }

        reader.close();

        for (Student1 st : list) {
            System.out.println(st.getSid() + "," + st.getName() + "," + st.getAge() + "," + st.getAddress());
        }
    }
}

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

需求：键盘录入5个学生信息（姓名，语文成绩，数学成绩，英语成绩）。要求按照成绩总分从高到低写入文本文件
格式：姓名,语文成绩,数学成绩,英语成绩
1）定义学生类
2）创建TreeSet集合，通过比较器排序进行排序
3）键盘录入学生数据
4）创建学生对象，把键盘录入的数据对应赋值给学生对象的成员变量
5）把学生对象添加到TreeSet集合
6）创建字符缓冲输出流对象
7）遍历集合，得到每一个学生对象
8）把学生对象的数据拼接成指定格式的字符串
9）调用字符缓冲输出流对象的方法写数据
10）释放资源

学生类：

package Characters;

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

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 TreeSetToFile {
    public static void main(String[] args) throws IOException {
        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?s2.getChinese() - s1.getChinese():num;
                int num3 = num2 == 0?s2.getMath() - s1.getMath():num2;
                int num4 = num3 == 0?s1.getName().compareTo(s2.getName()):num3;
                return num4;
            }
        });

        for(int i = 0; i < 5; i++){
            Scanner sc = new Scanner(System.in);
            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();
            Student student = new Student(name, chinese, math, english);
            ts.add(student);
        }

        BufferedWriter writer = new BufferedWriter(new FileWriter("src\\Characters\\students.txt"));
        for(Student st : ts){
            StringBuilder sb = new StringBuilder();
            sb.append(st.getName()).append(",").append(st.getChinese()).append(",").append(st.getMath()).append(",").append(st.getEnglish());
            writer.write(sb.toString());
            writer.newLine();
            writer.flush();
        }

        writer.close();
    }
}

7.复制单级文件夹：

需求：把"E:\\学习"复制到D盘下
1）创建数据源目录File对象，路径是E:\\学习
2）获取数据远目录File对象的名称(学习)
3）创建目的地目录File对象，路径名是D:\\+学习组成
4）判断目的地目录目录对应的File是否存在，如果不存在，就创建
5）获取数据源目录下所有文件的File数组
6）遍历Fil数组，得到每一个File对象，该File对象就是数据源文件
7）获取数据源文件File对象的名称
8）创建目的地文件File对象，路径名为目的地目录+源文件名称
9）复制文件

package Characters;

import java.io.*;


public class CopyFolder {
    public static void main(String[] args) throws IOException {
        File f1 = new File("E:\\学习");
        String f1Name = f1.getName();

        File f2 = new File("D:",f1Name);

        if(!f2.exists()){
            f2.mkdir();
        }

        File[] files = f1.listFiles();
        for(File file : files){
            String name = file.getName();
            File destFile = new File(f2,name);
            copyFile(file,destFile);
        }

    }

    private static void copyFile(File file, File destFile) throws IOException {
        BufferedInputStream fis = new BufferedInputStream(new FileInputStream(file));
        BufferedOutputStream fos = new BufferedOutputStream(new FileOutputStream(destFile));

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

8.复制多级文件夹：

需求：把"E:\\谷歌"复制到D盘目录下
1）创建数据源File对象，路径是E:\\谷歌
2）创建目的地File对象，路径是D:\\
3）写方法实现文件夹的复制，参数为数据源File对象和目的地File对象
4）判断数据源File是否为目录
	是：
		A：在目的地下创建和数据源File名称一样的目录
		B：获取数据源File下所有文件或者目录的File数组
		C：遍历该File数组，得到每一个File对象
		D：把该File作为数据源File对象，递归调用复制文件夹的方法
	不是：说明是文件，直接复制，用字节流

package Characters;

import java.io.*;

public class CopyFolders1 {
    public static void main(String[] args) throws IOException {
        File scrFile = new File("E:\\谷歌");
        File destFile = new File("D:\\");
        copyFolder(scrFile,destFile);
    }

    //复制文件夹
    private static void copyFolder(File scrFile, File destFile) throws IOException {
        if(scrFile.isDirectory()){
            String scrFileName = scrFile.getName();
            File newFolder = new File(destFile, scrFileName);
            if(!newFolder.exists()){
                newFolder.mkdir();
            }

            File[] FileArray = scrFile.listFiles();
            for(File file : FileArray){
                copyFolder(file,newFolder);
            }
        }else{
            File newFile = new File(destFile,scrFile.getName());
            copyFile(scrFile,newFile);
        }
    }
	//复制文件
    private static void copyFile(File scrFile, File destFile) throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(scrFile));
        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();
    }
}