JAVA中的几种I/O流

    private static String path; //文件的绝对路径
    private static String name; //文件名
    private static String extension; //文件扩展名
    private static StringBuffer txt = null; //读取的文本信息
    private static int len; //从输入流中一次读取的长度
    private static Vector vector = null; //保存输入流对象

    private static FileInputStream input = null; //文件输入流
    private static BufferedReader reader = null; //缓存文本输入流
    private static BufferedWriter writer  = null; //缓存文本输出流
    private static SequenceInputStream sequenceInput = null; //合并输入流
    private static DataInputStream dataInput = null; //二进制数据输入流
    private static PipedInputStream pipedInput = null; //二进制管道数据输入流
    private static PipedOutputStream pipedOut = null;  //二进制管道数据输出流

     /**
     * 初始化变量
     */
    static {
         try {
            path = "";
            name = "";
            txt = new StringBuffer();
            vector = new Vector();
            pipedInput = new PipedInputStream();
            pipedOut = new PipedOutputStream(pipedInput);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

一.文件输入流

            path = fileChooser.getSelectedFile().getAbsolutePath();
            input = new FileInputStream(new File(path));
            byte[] bits = new byte[1024];
            len = input.read(bits);
            while (len != -1) {
                txt.append(bits.toString());
                len = input.read(bits);
            }
            input.close();

二.缓存文本输入流

            reader = new BufferedReader(new FileReader(new File(path)));
            String text = reader.readLine();
            while (text != null) {
                txt.append(text).append("\n");
                text = reader.readLine();
            }
            reader.close();

三.合并输入流

            for (.....) {
                path = fileChooser.getSelectedFiles()[i].getAbsolutePath();
                input = new FileInputStream(new File(path));
                vector.add(input);
             }
            sequenceInput = new SequenceInputStream(vector.elements());
            byte[] bits = new byte[1024];
            len = sequenceInput.read(bits);
            while (len != -1) {
                txt.append(bits.toString());
                len = sequenceInput.read(bits);
            }
            sequenceInput.close();

四.二进制数据输入流

            dataInput = new DataInputStream(new FileInputStream(new File(path)));
            byte[] bits = new byte[1024];
            len = dataInput.read(bits);
            while (len != -1) {
                txt.append(bits.toString());
                len = dataInput.read(bits);
            }
            dataInput.close();

五.二进制管道数据输入流

            PipedInputStream 和 PipedOutputStream 在两个线程之间传递信息
            Thread thread1= new Thread1();
            Thread thread2= new Thread2();
            thread1.start();
            thread2.start();


//线程1负责接受线程2发送的消息
class Thread1 extends Thread {
    private IO io;

    public thread1() throws Exception{
        io = new IO();
    }

    public void run() {
        try {
            io.input();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

// 线程2负责向线程1发送消息
class Thread2 extends Thread {
    private IO io;

    public thread2() throws Exception {
        io = new IO();
    }

    public void run(){
        try {
            io.out();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

//类IO有发送和接受消息的的方法
class IO {
    public static int flag;
    private byte[] bits = new byte[1024];
    private int len;

    public synchronized void input() throws Exception {
        pipedInput = ExeMethod.input();
        len = pipedInput.read(bits);

        while (len == -1) {
            this.wait();
        }

        while (len != -1) {
            System.out.println("Input context:" + bits.toString());
            len = pipedInput.read(bits);
        }
        System.out.println("receive sucess");
        pipedInput.close();
    }

    public synchronized void out() throws Exception {
        pipedOut = ExeMethod.out();
        pipedOut.write(1);
        pipedOut.flush();
        pipedOut.close();
    }
}