浅析IO流之特殊操作流

标准输入、输出流

标准输入流

标准输出流

标准输入、输出流

System类中有两个静态的成员变量：

public static final InputStream in：标准输入流。通常该流对应于键盘输入或由主机环境或用户指定的另一个输入源

public static final PrintStream out：标准输出流。通常该流对应于显示输出或由主机环境或用户指定的另一个输出目标

标准输入流

自己实现键盘录入数据 BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

public class SystemInDemo {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("请输入一个字符串：");
        String line = br.readLine();
        System.out.println("你输入的字符串是："+line);

        //想要输入什么类型的数据就使用包装类的方法

        System.out.println("请输入一个整数：");
        int i = Integer.parseInt(br.readLine());
        System.out.println("你输入的整数是：" + i);

        //自己实现键盘录入数据太麻烦了，所以Java就提供了一个类供我们使用
        Scanner sc = new Scanner(System.in);
    }
}

由上述代码可知，当我们自己实现键盘录入数据太麻烦，想必大家想起了我们最开始数据输入的方法，java提供了Scanner类供我们实现数据输入的操作。Scanner sc = new Scanner(System.in);

标准输出流

输出语句的本质：是一个标准的输出流

PrintStream ps = System.out;
PrintStream类有的方法，System.out都可以使用

public class SystemOutDemo {
    public static void main(String[] args) {
        //public static final PrintStream out：标准输出流
        PrintStream ps = System.out;

        //能够方便地打印各种数据值
        //ps.print("乔巴菌儿");
        //ps.print(21);

        //ps.println("乔巴菌儿");//换行操作
        //ps.println(21);

        //System.out的本质是一个字节输出流
        System.out.println("乔巴菌儿");
        System.out.println(21);

        System.out.println();
        //System.out.print();
    }
}

打印流

打印流的分类以及特点：

字节打印流：PrintStream、字符打印流：PrintWriter
只负责输出数据，不负责读取数据
永远不会抛出IOException
有自己的特有方法

字节打印流

PrintStream(String fileName)：使用指定的文件名创建新的打印流

可以改变输出语句的目的地 public static void setOut(PrintStream out)：重新分配“标准”输出流

public class PrintStreamDemo {
    public static void main(String[] args) throws IOException {
        PrintStream ps = new PrintStream("Test08\\ps.txt");
        //调用父类方法；文件里的数据会自动转为ASCII值 97-->a
        ps.write(97);

        //自己特有方法
        //ps.print(97);
        ps.println(97);
        ps.println(98);//自动换行

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

使用继承父类的方法写数据，查看的时候会转码；使用自己的特有方法写数据，查看的数据原样输出。

print()必须带参数，不然报错；println()可为空。

字符打印流

字符打印流构造方法：

使用指定的文件名创建一个新的PrintWriter，而不需要自动执行刷新

PrintWriter(String fileName)

创建一个新的PrintWriter out：字符输出流 autoFlush：一个布尔值，如果为真，则println ， printf ，或format方法将刷新输出缓冲区（自动刷新）

PrintWriter(Writer out, boolean autoFlush)

public class PrintWriterDemo {
    public static void main(String[] args) throws IOException {
        //PrintWriter(String fileName) ：使用指定的文件名创建一个新的PrintWriter，而不需要自动执行行刷新
        /*PrintWriter pw = new PrintWriter("Test08\\pw.txt");
        //调用父类方法
        pw.write("乔巴菌儿");
        pw.write("\r\n");//换行
        pw.flush();//刷新
        pw.write("陈家湾湾草");
        pw.flush();

        //自己特有方法
        pw.println("乔巴菌儿");//自动换行
        pw.flush();
        pw.println("陈家湾湾草");*/


        //PrintWriter(Writer out, boolean autoFlush)：创建一个新的PrintWriter
        //自动刷新
        PrintWriter pw1 = new PrintWriter(new FileWriter("Test08\\pw1.txt"),true);
        pw1.println("乔巴菌儿");
        pw1.println("陈家湾湾草");

        pw1.close();
    }
}

对象序列化流、对象反序列化流

对象序列化介绍：

对象序列化：就是将对象保存到磁盘中，或者在网络中传输对象
这种机制就是使用一个字节序列表示一个对象，该字节序列包含：对象的类型、对象的数据和对象中存储的属性等信息
字节序列写到文件之后，相当于文件中持久保存了一个对象的信息
反之，该字节序列还可以从文件中读取回来，重构对象，对它进行反序列化

对象序列化流

对象序列化流： ObjectOutputStream

将Java对象的原始数据类型和图形写入OutputStream。可以使用ObjectInputStream读取（重构）对象。可以通过使用流的文件来实现对象的持久存储。如果流是网络套接字流，则可以在另一个主机上或另一个进程中重构对象

构造方法：

创建一个写入指定的OutputStream的ObjectOutputStream

ObjectOutputStream(OutputStream out)

序列化对象的方法：

将指定的对象写入ObjectOutputStream

void writeObject(Object obj)

public class Teacher implements Serializable {
    private String name;
    private int age;

    public Teacher() {
    }

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

    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 class ObjectOutputStreamDemo {
    public static void main(String[] args) throws IOException {
        //ObjectOutputStream(OutputStream out)：创建一个写入指定的OutputStream的ObjectOutputStream
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("Test08\\oos.txt"));

        //创建学生对象
        Teacher t = new Teacher("乔巴菌儿",21);

        //void writeObject(Object obj)：将指定的对象写入ObjectOutputStream
        oos.writeObject(t);

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

一个对象要想被序列化，该对象所属的类必须必须实现Serializable接口。

Serializable是一个标记接口，实现该接口，不需要重写任何方法。

对象反序列化流

对象反序列化流： ObjectInputStream

ObjectInputStream反序列化先前使用ObjectOutputStream编写的原始数据和对象

构造方法：

创建从指定的InputStream读取的ObjectInputStream

ObjectInputStream(InputStream in)

反序列化对象的方法：

从ObjectInputStream读取一个对象

Object readObject()

public class ObjectInputStreamDemo {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //ObjectInputStream(InputStream in)：创建从指定的InputStream读取的ObjectInputStream
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("Test08\\oos.txt"));

        //Object readObject()：从ObjectInputStream读取一个对象
        Object obj = ois.readObject();

        Teacher t = (Teacher) obj;
        System.out.println(t.getName() + "," + t.getAge());

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

Properties集合

Properties介绍：

是一个Map体系的集合类
Properties可以保存到流中或从流中加载
属性列表中的每个键及其对应的值都是一个字符串

Properties作为Map集合的特有方法：

设置集合的键和值，都是String类型，底层调用 Hashtable方法 put

Object setProperty(String key, String value)

使用此属性列表中指定的键搜索属性

String getProperty(String key)

从该属性列表中返回一个不可修改的键集，其中键及其对应的值是字符串

Set<String> stringPropertyNames()

public class PropertiesDemo02 {
    public static void main(String[] args) {
        //创建集合对象
        Properties pro = new Properties();

        //Object setProperty(String key, String value)：设置集合的键和值，都是String类型，底层调用Hashtable方法put
        pro.setProperty("灰太狼","999");
        pro.setProperty("红太狼","888");
        pro.setProperty("小灰灰","666");
        System.out.println(pro);

        //String getProperty(String key)：使用此属性列表中指定的键搜索属性
        System.out.println(pro.getProperty("灰太狼"));

        //Set<String> stringPropertyNames()：从该属性列表中返回一个不可修改的键集，其中键及其对应的值是字符串
        Set<String> names = pro.stringPropertyNames();
        for (String key :names) {
            //System.out.println(key);
            String value = pro.getProperty(key);
            System.out.println(key + "," + value);
        }
    }
}

Properties和IO流相结合的方法:

从输入字节流读取属性列表（键和元素对）

void load(InputStream inStream)

从输入字符流读取属性列表（键和元素对）

void load(Reader reader)

将此属性列表（键和元素对）写入此 Properties表中，以适合于使用 load(InputStream)方法的格式写入输出字节流

void store(OutputStream out, String comments)

将此属性列表（键和元素对）写入此 Properties表中，以适合使用 load(Reader)方法的格式写入输出字符流

void store(Writer writer, String comments)

public class PropertiesDemo03 {
    public static void main(String[] args) throws IOException {
        //把集合中的数据保存到文件, myStore();
        myStore();

        //把文件中的数据加载到集合
        myLoad();
    }

    private static void myLoad() throws IOException{
        Properties pro = new Properties();
        //void load(InputStream inStream)
        FileInputStream fis = new FileInputStream("Test08\\fos.txt");
        pro.load(fis);
        fis.close();
        System.out.println(pro);
    }

    private static void myStore() throws IOException {
        //创建集合
        Properties pro = new Properties();
        pro.put("灰太狼","999");
        pro.put("红太狼","888");
        pro.put("小灰灰","666");

       // void store(OutputStream out, String comments)
        FileOutputStream fos= new FileOutputStream("Test08\\fos.txt");
        pro.store(fos,null);
        fos.close();
    }
}