Java-IO-输入/输出流体系

处理流的用法

使用处理流来包装节点流，程序通过处理流来执行输入/输出功能，让节点与底层的I/O设备，文件交互

package filetest;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;

public class PrintStreamTest {

    public static void main(String[] args) {
        try {
            FileOutputStream fos=new FileOutputStream("E:\\Java-IO\\poem.txt");
            //PrintStream处理流来包装OutputStream
            PrintStream ps=new PrintStream(fos);
            //使用PrintStream执行输出
            ps.println("普通字符串");
            //直接使用PrintStream输出对象
            ps.println(new PrintStreamTest());
            ps.close();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }



    }

}

输入/输出流体系

分类	字节输入流	字节输出流	字符输入流	字符输出流
抽象基类	InputStream	OutputStream	Reader	Writer
访问文件	FileInputStream	FileOutputStream	FileReader	FileWriter
访问数组	ByteArrayInputStream	ByteArrayOutputStream	CharArrrayReader	CharArrayWriter
访问管道	PipedInputStream	PipedOutputStream	PipedReader	PipedWriter
访问字符串			StringReader	StringWriter
缓冲流	BufferedInputStream	BufferedOutputStream	BufferedReader	BufferedWriter
转换流	ObjectInputStream	ObjectOutputStream
抽象基类	FilterInputStream	FilterOutputStream	FilterReader	FilterWriter
打印流		PrintStream		PrintWriter
推回输入流	PushbackInputStream		PushbackReader
特殊流	DataInputStream	DataOutputStream

下面程序使用字符串作为物理节点的字符输入/输出流的用法

package filetest;

import java.io.IOException;
import java.io.StringReader;
import java.io.StringWriter;

public class StringNodeTest {

    public static void main(String[] args) {
        String src="做一个幸福的人\n"+"做一个上进的人";
        char[] buffer=new char[32];
        int hasRead=0;
        StringReader sr=new StringReader(src);
        //使用循环读取字符串
        try {
            while((hasRead=sr.read(buffer))>0)
            {
                System.out.println(new String(buffer, 0, hasRead));
            }
            sr.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        //创建StringWriter，实际上以一个StringBuffer作为输出节点
        StringWriter sw=new StringWriter();

        sw.write("她在远方等我");
        System.out.println(sw.toString());

    }

}

转换流

• InputStreamReader将字节输入流转换成字符输入流。
• OutputStreamWriter将字节输出流转换成字符输出流。

package filetest;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class KeyinTest {

    public static void main(String[] args) {
        //将System.in对象转换成Reader对象
        InputStreamReader sr=new InputStreamReader(System.in);
        //将普通的Reader包装成BufferedReader
        BufferedReader br=new BufferedReader(sr);
        String line="";
        //采用循环式来按行进行读取
        try {
            while((line=br.readLine())!=null)
            {
                if(line.equals("exit!"))
                {
                    System.exit(1);
                }
                System.out.println("输出的内容是："+line);
            }
            br.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}

推回输入流

• void unread(byte[]/char[] buf)：将一个字节/字符串数组内容推回到缓冲区，从而允许重复读取刚刚读取的内容。
• void unread(byte[]/char[] buf, int off, int len)：将一个字节/字符串数组从off开始，长度为len字节/字符的内容推回到缓冲区，从而允许重复读取刚刚读取的内容。
• void unread()：将一个字节/字符内容推回到缓冲区，从而允许重复读取刚刚读取的内容。

package filetest;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.PushbackInputStream;
import java.io.PushbackReader;

public class PushbackTest {

    public static void main(String[] args) {

        try {
            //创建一个PushbackReader对象，指定推回缓冲区的长度
            PushbackReader pr=new PushbackReader(new FileReader("E:\\Java-IO\\first.txt"), 64);
            char[] buf=new char[32];
            //保存上次读取的字符串美容
            String lastContent="";
            int hasRead=0;
            //循环读取文件内容
            while((hasRead=pr.read(buf))>0)
            {
                //将读取内容转换成字符串
                String content=new String(buf, 0, hasRead);
                int targetIndex=0;
                //将上次读取的字符串和本次读取的字符串拼接起来，
                //查看是否包含目标字符串，如果包含目标字符串
                if((targetIndex=(lastContent+content).indexOf("new PushbackReader"))>0)
                {
                    //将本次内容和上次内容一起推回缓冲区
                    pr.unread((lastContent+content).toCharArray());
                    //重新定义一个长度为targetIndex的char数组
                    if(targetIndex>32)
                    {
                        buf=new char[targetIndex];
                    }
                    //再次读取指定长度的内容（就是目标字符串之前的内容）
                    pr.read(buf, 0, targetIndex);
                    System.out.println(new String(buf,0,targetIndex));
                    System.exit(0);
                }
                else {
                    //打印上次内容
                    System.out.println(lastContent);
                    //将本次内容设为上次读取的内容
                    lastContent=content;
                }
            }
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

}