简单记录一下 Java IO流知识点

输出流：OutputStream和Writer为基类

输入流：InputStream和Reader为基类

读取

package cn.pojo;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
public class InputStreamDemo {
            public static void main(String[] args) {
                   readByte();
                   readArr();
            }
            /**
             * 读取字节
             */
            public static void readByte() {
                         // 1、明确源数据源
                   File f = new File("F:\\1\\余文佳\\1.txt");
                         // 2、构建输入流对象
                   InputStream ins = null;
                    try {
                       ins = new FileInputStream(f);
                       int i;
                                     // 3、 读取文件字符
                       while ((i = ins.read()) != -1) {
                       System.out.println("i=" + i); // 输出为转化的ascii码值     
           }  catch (Exception e) {
                          e.printStackTrace();
                        } finally {
                       if (ins != null) {
                              try {
                                ins.close();
                               } catch (Exception e) {
                                e.printStackTrace();}
                                    }
                        }
            }
            // 2、使用缓冲数组的方法读取文件内容,提高效率
            public static void readArr() {
                         // 1、明确源数据源
                         File f = new File("F:/1/余文佳/1.txt");
                         // 2、构建流的对象
                         InputStream ins = null;
                         try {
                                 ins = new FileInputStream(f);
                                     // 3、声明缓冲数组
                                 int i; // 表示读取了多少个字符到数组中
                                 byte[] bt = new byte[5]; // 字节缓冲数组
                                     // 4、读取数据到数组中
                                 while ((i = (ins.read(bt))) != -1) {
                                     for (int j = 0; j < i; j++) {
                                            System.out.print((char) bt[j]);
                                                }
                                    }
                        } catch (Exception e) {
                                    e.printStackTrace();
                        } finally {
                                     //关闭流
                                    try {
                                                if (ins != null) {
                                                            ins.close();
                                                }
                                    } catch (Exception e) {
                                                e.printStackTrace();
                                    }
                        }
            }
}

写入

public final class OutputStreamDemo {

        public static void main(String[] args) {
                // 1、明确目标数据源
                File f = new File("E:/java48/java48.txt");
                // 判断文件是否存在，否则创建
                if (!f.exists()) {
                    f.getParentFile().mkdirs();// 先创建目录
                    try {
                        f.createNewFile();// 再创建文件 此处需要处理异常，
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
                // 2、构建输出流对象（通过子类实例化父类的对象）
                OutputStream outs = null ; // 首先准备好一个输出的对象
                try {
                    outs = new FileOutputStream(f) ; // 构造方法 ，实例化，此处需要处理异常
                    // 执行写入文件的操作
                    String st = "java48班" ; // 创建字符串
                    byte[] bt = st.getBytes(); // 只能输出byte数组，所以将字符串变为byte数组
                                                           // 使用String st.getByte();方法
                    outs.write(bt); // 将内容输出，保存文件
                    outs.flush(); // 刷新输出流
                    System.out.println("写入成功！"); // 若（文件夹必须存在）没有文件，会创建文件然后写入;若文件已有相同内容，则直接覆盖
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                        // 4、关闭资源
                        if (outs != null) { 
                        try {
                            outs.close(); // 此处也要处理异常
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                }
        }
}

利用读写流 实现文件的复制

public class Demo {
     // 检查文件是否存在，否则创建
     public static void checkFile(File file) {
           if (!file.exists()) {
                file.getParentFile().mkdirs();// 创建多级目录
                try {
                     file.createNewFile();// 创建文件，此处需要处理异常
                     System.out.println("创建文件成功！");
                } catch (Exception e) {
                     e.printStackTrace();
                }
           }
     }
     public static void main(String[] args) {
           // 明确源文件和目标文件
           File o = new File("E:/java48/java48.txt");// 源文件
           File t = new File("E:/java48/新建.txt");// 目标文件
           checkFile(t);// 这里仅仅检查了目标文件
           // 构建输入、输出流对象
           InputStream ins = null; // 输入的对象
           OutputStream outs = null; // 输出的对象
           // 进行实例化,需要处理异常
           try {
                ins = new FileInputStream(o);// 源文件作为输入对象--->若要拼接后面加上true
                outs = new FileOutputStream(t);// 目标文件作为输出对象--->若要拼接后面加上true
                // 创建缓冲数组
                byte[] b = new byte[1024];
                int len = 0;
                // 执行边读边写操作
                while ((len = ins.read(b)) != -1) {
                     outs.write(b, 0, len);
                }
                // 刷新输出流
                outs.flush();
                // 至此复制成功
           } catch (Exception e) {
                e.printStackTrace();
           } finally {
                // 关闭流（先开的后关）
                try {
                     if (outs != null) {// 为了避免空指针异常，进行判空
                           outs.close();
                     }
                     if (ins != null) {
                           ins.close();
                     }
                } catch (Exception e) {
                     e.printStackTrace();
                }
           }
     }
}

对象序列化流

        

对象序列化：就是将对象保存到磁盘中，或者在网络中传输对象

这种机制就是使用一个字节序列表示一个对象，该字节序列包含：对象的类型、对象的数据和对象中存储的属性等信息

字节序列写到文件之后，相当于文件中持久保存了一个对象的信息

反之，该字节序列还可以从文件中读取回来，重构对象，对它进行反序列化

总的理解就是序列化是把一个对象存入文件中，而反序列化就是把文件中序列化的对象读取出来。
 

对象的写入 需要实现序列化接口

public class Student implements Serializable {
 
}
测试类
public class ObjectOutputStreamDemo {
    public static void main(String[] args) throws IOException {
        //ObjectOutputStream(OutputStream out)：创建一个写入指定的OutputStream的ObjectOutputStream
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("myOtherStream\\oos.txt"));
        //创建对象
        Student s = new Student("林青霞",30);
        //void writeObject(Object obj)：将指定的对象写入ObjectOutputStream
        oos.writeObject(s);
        //释放资源
        oos.close();
    }
}

反序列化

public class ObjectInputStreamDemo {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //ObjectInputStream(InputStream in)：创建从指定的InputStream读取的ObjectInputStream
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("myOtherStream\\oos.txt"));
 
        //Object readObject()：从ObjectInputStream读取一个对象
        Object obj = ois.readObject();
 
        Student s = (Student) obj;
        System.out.println(s.getName() + "," + s.getAge());
 
        ois.close();
    }
}

综合案例

        (1)定义学生类,包含姓名(String name),性别(String gender),年龄(int age)三个属性,生成空参有参构造,set和get方法,toString方法
        (2)键盘录入6个学员信息(录入格式:张三,男,25),要求有两个相同的信息,将6个学员信息存入到ArrayList集合中
        (3)将存有6个学员信息的ArrayList集合对象写入到D:\\StudentInfo.txt文件中
        (4)读取D:\\StudentInfo.txt文件中的ArrayList对象
        (5)对ArrayList集合中的6个学生对象进行去重并按照年龄从小到大的顺序排序
        (6)将ArrayList集合中排序后的结果利用PrintWriter流写入到E:\\StudentInfo.txt文件中(写入格式：张三-男-25)
————————————————

//学生类
package IO.Work;
 
import java.io.Serializable;
 
public class Stduent implements Serializable {
    private String name;
    private String gender;
    private int age;
 
    public Stduent() {
    }
 
    public Stduent(String name, String gender, int age) {
        this.name = name;
        this.gender = gender;
        this.age = age;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public String getGender() {
        return gender;
    }
 
    public void setGender(String gender) {
        this.gender = gender;
    }
 
    public int getAge() {
        return age;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
 
    @Override
    public String toString() {
        return "Stduent{" +
                "name='" + name + '\'' +
                ", gender='" + gender + '\'' +
                ", age=" + age +
                '}';
    }
}

public class inputAndOutput {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        ArrayList<Stduent> array = new ArrayList<Stduent>();
        InPut(array);
        writerToFile(array);
        readArrayList(array);
        removeAndSort(array);
        writerArrayList(array);
    }

    //将ArrayList集合中排序后的结果利用PrintWriter流写入到E:\\Student.txt文件中
    private static void writerArrayList(ArrayList<Stduent> array) throws IOException {
        PrintWriter pw = new PrintWriter(new FileWriter("leveleight\\src\\IO\\paper\\Stduent"));
        //遍历集合
        for (Stduent stduent : array) {
            pw.print(stduent);
        }
        pw.close();
    }

    //对ArrayList集合中的6个学生对象进行去重并按照年龄从小到大的顺序排序
    private static ArrayList<Stduent> removeAndSort(ArrayList<Stduent> array) {

        //创建TreeSet集合对象使用比较器排序,去重
        TreeSet<Stduent> ts = new TreeSet<Stduent>(new Comparator<Stduent>() {
            @Override
            public int compare(Stduent s1, Stduent s2) {
                int num = s1.getAge() - s2.getAge();
                return num;
            }
        });
        ts.addAll(array);
        array.clear();
        array.addAll(ts);
        System.out.println("去重排序后：");
        for (Stduent st : array) {
            System.out.println(st);
        }
        return array;
    }

    //读取StudentInfo.txt文件中的ArrayList对象
    private static ArrayList<Stduent> readArrayList(ArrayList<Stduent> array) throws IOException, ClassNotFoundException {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("leveleight\\src\\IO\\paper\\StudentInfo.txt"));
        Object obj = ois.readObject();
        Stduent s = (Stduent) obj;
        System.out.println("原始数据" + s.getName() + "," + s.getGender() + "," + s.getAge());
        ois.close();
        return array;
    }

    //将存有6个学员信息的ArrayList集合对象写入到StudentInfo.txt文件中
    private static void writerToFile(ArrayList<Stduent> array) throws IOException {
        //由于Stduent是一个对象，那么存入文件就需要使用对象序列化
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("leveleight\\src\\IO\\paper\\StudentInfo.txt", true));
        oos.writeObject(array);
        oos.close();
    }

    //键盘录入6个学员信息(录入格式:张三,男,25),要求有两个相同的信息,将6个学员信息存入到ArrayList集合中
    //创建键盘录入方法体
    private static void InPut(ArrayList<Stduent> array) {
        Scanner sc = new Scanner(System.in);
        String[] strArr = new String[3];
        System.out.println("请输入六个学员信息！");
        for (int i = 0; i < 6; i++) {
            System.out.println("请输入第" + (i + 1) + "个学生的信息(格式:xxx,男,25)");
            strArr = sc.next().split("，");//，,
            array.add(new Stduent(strArr[0], strArr[1], Integer.parseInt(strArr[2])));
        }
    }
}