IO流进阶2

标准输入流 & 转换流 & 打印流

标准输入输出流

public static final InputStream in:标准输入流
public static final PrintStream out:标准输出流

转换流
OutputStreamWriter:将字节输出流转换为字符输出流

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Writer;

public class OutputStreamWriterDemo {
    public static void main(String[] args) throws IOException   {
        //method2();

        //创建输入流对象
        BufferedReader br = new BufferedReader(new FileReader("SystemInOutDemo.java"));
        //创建输出流对象
        //OutputStream os = System.out;
        //Writer w = new OutputStreamWriter(System.out);//多态，父类型引用指向子类对象
        //BufferedWriter bw = new BufferedWriter(w);

        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));


        //进行数据的读写
        String line;//用于存储读取到的数据
        while((line = br.readLine()) != null) {
            bw.write(line);
            bw.newLine();
        }

        //释放资源
        bw.close();
        br.close();

    }

    private static void method2() throws FileNotFoundException, IOException {
        //创建输入流对象
        BufferedReader br = new BufferedReader(new FileReader("SystemInOutDemo.java"));
        //创建输出流对象
        //OutputStream os = System.out;
        Writer w = new OutputStreamWriter(System.out);//多态，父类型引用指向子类对象

        //进行数据的读写
        String line;//用于存储读取到的数据
        while((line = br.readLine()) != null) {
            w.write(line);
            w.write("\r\n");
        }

        //释放资源
        w.close();
        br.close();
    }

    private static void method() throws FileNotFoundException, IOException {
        //创建输入流对象
        BufferedReader br = new BufferedReader(new FileReader("SystemInOutDemo.java"));
        //创建输出流对象
        OutputStream os = System.out;

        String line;//用于存储读取到的数据
        while((line = br.readLine()) != null) {
            os.write(line.getBytes());
            os.write("\r\n".getBytes());
        }

        //释放资源
        os.close();
        br.close();
    }
}

InputStreamReader:将字节输入流转换为字符输入流

import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;

public class InputStreamReaderDemo {
    public static void main(String[] args) throws IOException  {
        //创建输入流对象
        InputStream is = System.in;
        Reader r = new InputStreamReader(is);
        //创建输出流对象
        FileWriter fw = new FileWriter("a.txt");

        //读写数据
        char[] chs = new char[1024];
        int len;
        while((len = r.read(chs)) != -1) {
            fw.write(chs,0,len);
            fw.flush();
        }

        //释放资源
        fw.close();
        is.close();

    }

    private static void method() throws IOException {
        //创建输入流对象
        InputStream is = System.in;
        //创建输出流对象
        FileWriter fw = new FileWriter("a.txt");
        //读写数据
        byte[] bys = new byte[1024];
        int len;//用于存储读取到的字节个数
        while((len = is.read(bys)) != -1) {
            fw.write(new String(bys,0,len));
            fw.flush();
        }

        //释放资源
        fw.close();
        is.close();
    }
}

打印流

打印流添加输出数据的功能，使它们能够方便地打印各种数据值表示形式.
字符打印流 PrintWriter
void print(String str): 输出任意类型的数据，
void println(String str): 输出任意类型的数据，自动写入换行操作

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.PrintWriter;

public class PrintWriterDemo {
    public static void main(String[] args) throws IOException  {
        //创建打印流对象
        PrintWriter pw = new PrintWriter("b.txt");
        //写出数据
        pw.write("hello");
        pw.write("world");
        pw.write("java");
        //释放资源
        pw.close();
    }
}

利用打印流实现自动换行与自动更新

import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

public class PrintWriterDemo2 {
    public static void main(String[] args) throws IOException  {
        //method();
        //创建打印流对象
        //PrintWriter pw = new PrintWriter("d.txt");
        PrintWriter pw = new PrintWriter(new FileWriter("d.txt"),true);

        pw.println("hello");
        pw.println("world");
        pw.println("java");

        //释放资源
        //pw.close();
    }

    private static void method() throws FileNotFoundException {
        //创建打印流对象
        PrintWriter pw = new PrintWriter("c.txt");
        pw.print("hello");
        pw.println("world");
        pw.println("java");
        //释放资源
        pw.close();
    }
}

利用打印流将根目录下的SystemInOutDemo.java复制到d:\SystemInOutDemo.java下

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

public class PrintWriterDemo3 {
    public static void main(String[] args) throws IOException  {
        //创建输入流对象
        BufferedReader br = new BufferedReader(new FileReader("SystemInOutDemo.java"));
        //创建打印流对象
        PrintWriter pw = new PrintWriter(new FileWriter("d:\\SystemInOutDemo.java"),true);
        String line;//用于存储读取到的每行数据
        while((line = br.readLine()) != null) {
            pw.println(line);
        }
        //释放资源
        pw.close();
        br.close();
    }

}

对象操作流

概述
用于从流中读取对象的
ObjectInputStream 称为 反序列化流,利用输入流从文件中读取对象
ObjectOutputStream 称为 序列化流,利用输出流向文件中写入对象
特点：用于操作对象。可以将对象写入到文件中，也可以从文件中读取对象。

利用序列化流读写对象

import java.io.Serializable;

public class Student implements Serializable {

    String name;
    int age;

    public Student(String name,int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age +"]";
    }
}


import java.io.EOFException;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;


public class ObjectOutputStreamDemo {
    public static void main(String[] args) throws IOException, ClassNotFoundException  {
        //method();
        //创建对象输入流的对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("a.txt"));
        try {
            while(true) {
                Object obj = ois.readObject();
                System.out.println(obj);
            }
        } catch(EOFException e) {
            System.out.println("读到了文件的末尾");
        }

        //释放资源
        ois.close();
    }

    private static void method() throws IOException, FileNotFoundException {
        //创建对象输出流的对象
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("a.txt"));
        //创建学生对象
        Student s = new Student("zhangsan",18);
        Student s2 = new Student("lisi",19);
        //写出学生对象
        oos.writeObject(s);
        oos.writeObject(s2);
        //释放资源
        oos.close();
    }

}

解决对象输入流读取对象出现异常的问题

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;

public class ObjectOutputStreamDemo3 {
    public static void main(String[] args) throws IOException, ClassNotFoundException   {
        //method();

        //创建对象输入流的对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("b.txt"));
        //读取数据
        Object obj = ois.readObject(); 
        //向下转型，获取具体的子类对象
        ArrayList list = (ArrayList) obj;
        for (Student student : list) {
            System.out.println(student);
        }
        //释放资源
        ois.close();
    }

    private static void method() throws IOException, FileNotFoundException {
        //创建对象输出流的对象
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("b.txt"));
        //创建集合对象
        ArrayList list = new ArrayList();
        //添加学生对象
        list.add(new Student("wangwu",30));
        list.add(new Student("zhaoliu",28));
        //写出集合对象
        oos.writeObject(list);
        //释放资源
        oos.close();
    }
}

解决读写对象版本不一致问题

import java.io.Serializable;

public class Student implements Serializable {


    private static final long serialVersionUID = 6361890890437825953L;
    String name;
    int age;
    String gender;


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


    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + ", gender=" + gender + "]";
    }

}



import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;


public class ObjectOutputStreamDemo4 {
    public static void main(String[] args) throws IOException, ClassNotFoundException  {
        //method();

        method2();
    }

    //读取学生对象
    private static void method2() throws IOException, FileNotFoundException, ClassNotFoundException {
        //创建对象输入流的对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("c.txt"));
        //读取对象
        Object obj = ois.readObject();
        System.out.println(obj);
        //释放资源
        ois.close();
    }

    //写出学生对象
    private static void method() throws IOException, FileNotFoundException {
        //创建对象输出流的对象
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("c.txt"));
        //创建的学生对象
        Student s = new Student("qianqi",28);
        //写出学生对象
        oos.writeObject(s);
        //释放资源
        oos.close();
    }
}

Properties集合

Properties介绍

Properties 类表示了一个持久的属性集。Properties 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串。

特点：
1、Hashtable的子类，map集合中的方法都可以用。
2、该集合没有泛型。键值都是字符串。
3、它是一个可以持久化的属性集。键值可以存储到集合中，也可以存储到持久化的设备(硬盘、U盘、光盘)上。键值的来源也可以是持久化的设备。
4、有和流技术相结合的方法。

利用Properties存储键值对

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

public class PropertiesDemo2 {
    public static void main(String[] args) {
        //创建属性列表对象
        Properties prop = new Properties();
        //添加映射关系
        prop.put("CZBK001", "zhangsan");
        prop.put("CZBK002", "lisi");
        prop.put("CZBK003", "wangwu");

        //遍历属性列表
        //获取所有的key，通过key获取value
        Set