IO(2)

节点流和处理流

节点流：如果流封装的是某种特定的数据源，如文件、字符串、字符串数组等， 则称为节点流

处理流/包装流：如果流封装的是其它流对象，称为处理流。 处理流提供了缓冲功能， 提高读写效率,同时增加了一些新的方法

  BufferedInputStream和BufferedOutputStream

package com.ffyc.javaio.file;

import java.io.*;

public class StreamDemo3 {
    public static void main(String[] args) throws IOException {

        FileInputStream in = new FileInputStream("D:/demo6.txt");
        FileOutputStream out = new FileOutputStream("D:/demo5.txt");
        BufferedInputStream bin = new BufferedInputStream(in);
        BufferedOutputStream bout = new BufferedOutputStream(out);

       int  size = 0;
       byte []b = new byte[1024];
       while((size = bin.read(b))!= -1){
            bout.write(b);
       }
       bout.flush();
       bin.close();
       bout.close();
    }
}

源码如下：

 FileReader和FileWriter

public static void main(String[] args) throws IOException {

        FileReader reader = new FileReader("D:/demo6.txt");
        FileWriter writer = new FileWriter("D:/demo3.txt");
        int c = 0;
        while((c = reader.read())!=-1){
            writer.write(c);
        }
        reader.close();
        writer.close();
}

利用数组：

public static void main(String[] args) throws IOException {

        FileReader reader = new FileReader("D:/demo6.txt");
        FileWriter writer = new FileWriter("D:/demo3.txt");
        char[]b = new char[100];
        int size = 0;
        while((size = reader.read(b))!=-1){
            writer.write(b,0,size);
        }
        reader.close();
        writer.close();
       
    }

  BufferedReader和BufferedWriter

package com.ffyc.javaio.file;

import java.io.*;

public class StreamDemo4 {
    public static void main(String[] args) throws IOException {

        FileReader reader = new FileReader("D:/demo6.txt");
        FileWriter writer = new FileWriter("D:/demo3.txt",true);//写入数据时可以保留之前的向后面追加
        BufferedReader bufferedReader = new BufferedReader(reader);
        BufferedWriter bufferedWriter = new BufferedWriter(writer);

             String line  = null;
             while ((line = bufferedReader.readLine())!=null){
                 System.out.println(line);//readlLine()一次读取一行数据
                 bufferedWriter.write(line);
                 bufferedWriter.newLine();//插入换行符
             }
             bufferedWriter.flush();
             bufferedReader.close();
             bufferedWriter.close();
    }
}

print流

package com.ffyc.javaio.file;

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

public class PrintDemo {
    public static void main(String[] args) throws FileNotFoundException {
         /*
         打印流：单向的从程序中向目标文件输出
         PrintWriter 打印字符流
          */
        PrintWriter out = new PrintWriter("D:/demo.html");
        out.print("<h1>你好客户端<h1>");
        out.print("<h2>你好客户端<h2>");
        out.print("<h2>你好客户端<h2>");
        out.print("<h3>你好客户端<h3>");
        out.close();
    }
}

对象序列化

● 对象的寿命通常随着生成该对象的程序的终止而终止。 有时候，可能需 要将对象的状态保存下来，在需要时再将对象恢复。

● 对象的输入输出流 : 主要的作用是用于写入对象信息与读取对象信息。 对象信息 一旦写到文 件上那么对象的信息就可以做到持久化了.

对象的输出流:ObjectOutputStream

对象的输流:ObjectInputStream

● 在ObjectInputStream 中用readObject()方法可以直接读取一个对象， ObjectOutputStream中用writeObject()方法可以直接将对象保存到输出流中

package com.ffyc.javaio.file;

import java.io.*;
import java.util.Date;

public class ObjectStream {
    /*
    对象储存在内存中，程序终止运行，内存数据清空
    有时候需要保存对象中的数据，需要用流对象，将对象数据输出到文件中，做到对象数据的持久化
    ObjectInputStream
    ObjectOutputStream  都属于处理流
    此对象称为对象的序列化和反序列化，其中反序列化也是一种创建对象的方法
     */
    public static void main(String[] args) throws IOException, ClassNotFoundException {
/*
       FileOutputStream fout = new FileOutputStream("D:/demo1.txt");
        ObjectOutputStream out = new ObjectOutputStream(fout);
            Date date = new Date();
            String s  = "abc";
            out.writeObject(date);
            out.writeObject(s);

            out.flush();
            out.close();
 */

        FileInputStream in = new FileInputStream("D:/demo1.txt");
        ObjectInputStream oin = new ObjectInputStream(in);
        Date date = (Date)oin.readObject();
        String s  = (String)oin.readObject();
        System.out.println(date);
        System.out.println(s);


    }
}

Serializable序列化接口

如果需要将某个类的对象进行序列化，那么此类必须实现Sericalizable

它会为类生成一个版本号，如果不显示定义版本号，会自定默认生成，会有一个问题，每次当类改变了，版本号会重新生成

transient关键字

默认情况下当执行了对象序列化的时候会将类中的全部属性的内容进行全部的序列化操作， 但是很多情况下有一些属性可能并不需要序列化的处理，这个时候就可以在属性的定义上使 用transient关键字来完成了。

private transient String name