Java IO流经典实例

IO流框架

字节流

1、FileInputStream&FileOutputStream

import java.io.FileInputStream;
import java.io.FileOutputStream;

/**
 * @author Hanlin Wang
 */

public class FileStream {
    public static void main(String[] args) throws Exception {
        FileInputStream in = new FileInputStream("from.txt");

        //准备缓冲字节数组，大小为1024个字节
        byte[] buf = new byte[1024];

        //开始时间
        long start = System.currentTimeMillis();

        //in读取字节，将读取的字节保存到buf中。len为in向buf中保存的字节数
        int len = in.read(buf);

        //读取完成之后，释放资源
        in.close();

        //通过buf打印结果
        System.out.println(new String(buf, 0, len));

        FileOutputStream out = new FileOutputStream("to.txt");

        //将buf中的字节数组写入到to.txt中
        out.write(buf, 0, len);

        //释放资源
        out.close();

        //结束时间
        long end = System.currentTimeMillis();

        //打印运行时间
        System.out.println("运行时间为："+(end - start));
    }
}

2、BufferedInputStream&BufferedOutputStream

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;

/**
 * @author Hanlin Wang
 */

public class BufferedStream {
    public static void main(String[] args) throws Exception {
        BufferedInputStream in = new BufferedInputStream(
                new FileInputStream("from.txt"));

        //字节数组
        byte[] buf = new byte[1024];

        //开始时间
        long start = System.currentTimeMillis();

        //len为已读取的字节数
        int len = in.read(buf);

        //读取完成后，释放资源
        in.close();

        //打印读取的数据
        System.out.println(new String(buf, 0, len));

        BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream("to.txt"));

        //写入数据到to.txt
        out.write(buf, 0, len);

        //写入完成后，释放资源
        out.close();

        //结束时间
        long end = System.currentTimeMillis();

        //打印运行时间
        System.out.println("运行时间为："+(end - start));
    }
}

3、ByteArrayInputStream&ByteArrayOutputStream

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.FileOutputStream;

/**
 * @author Hanlin Wang
 */

public class ByteArrayStream {
    public static void main(String[] args) throws Exception{
        //输入流，通过构造函数注入原始数据
        ByteArrayInputStream in = new ByteArrayInputStream("whataya want from me".getBytes());

        //输出流，接受输入流的数据
        ByteArrayOutputStream out2 = new ByteArrayOutputStream();

        int len;

        while ((len=in.read())!=-1) {
            out2.write(len);
        }

        //关闭资源
        in.close();

        //关闭资源
        out2.close();

        FileOutputStream out = new FileOutputStream("to.txt");

        //将out2的数据通过toByteArray()方法位字节数组，然后out写入to.txt
        out.write(out2.toByteArray());

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

4、DataInputStream&DataOutputStream

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;

/**
 * @author Hanlin Wang
 */

public class DataStream {
    public static void main(String[] args) throws Exception{
        //这里使用了三层装饰
        FileOutputStream des = new FileOutputStream("to.txt");
        BufferedOutputStream buf = new BufferedOutputStream(des);
        DataOutputStream out = new DataOutputStream(buf);

        //运用DataOutputStream的相关方法写数据
        out.writeBoolean(true);//写入布尔值
        out.writeByte(12);//写入字节值
        out.writeUTF("您好");//写一个使用UTF-8编码的字符串
        out.writeChar('1');//写入字符

        out.close();

        //读取to.txt的数据
        FileInputStream des2 = new FileInputStream("to.txt");
        BufferedInputStream buf2 = new BufferedInputStream(des2);
        DataInputStream in = new DataInputStream(buf2);

        //必须与之间写入到to.txt的顺序相同
        System.out.println(in.readBoolean());
        System.out.println(in.readByte());
        System.out.println(in.readUTF());
        System.out.println(in.readChar());

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

5、ObjectInputStream&ObjectOutputStream

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

/**
 * @author Hanlin Wang
 */

public class ObjectStream {
    public static void main(String[] args) throws Exception{
        FileOutputStream out = new FileOutputStream("to.txt");
        ObjectOutputStream objout = new ObjectOutputStream(out);

        //创建Person对象
        Person p = new Person("张三", 19);

        //写入to.txt
        objout.writeObject(p);

        //释放资源
        objout.close();

        FileInputStream in = new FileInputStream("to.txt");

        ObjectInputStream objin = new ObjectInputStream(in);

        //读取to.txt中的数据
        Person p2 = (Person) objin.readObject();

        System.out.println(p2.toString());

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

//定义一个Person，实现Serializable接口，保证可序列化
class Person implements Serializable{
    private String name;
    private int age;

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

    public String toString(){
        return "姓名：" + name + " | 年龄：" + age;
    }
}

6、SequenceInputStream

import java.io.ByteArrayInputStream;
import java.io.FileOutputStream;
import java.io.SequenceInputStream;
import java.util.Enumeration;
import java.util.Vector;

/**
 * @author Hanlin Wang
 */

public class SequenceStream {
    public static void main(String[] args) throws Exception{
        //第一个inputstream
        ByteArrayInputStream in = new ByteArrayInputStream(
                "whataya want from me".getBytes());

        //第二个inputstream
        ByteArrayInputStream in2 = new ByteArrayInputStream(
                "\nnever close our eyes".getBytes());
        //释放资源（因为in、in2不做读写操作）
        in.close();
        in2.close();

        //用一个集合封装in、in2
        Vector<ByteArrayInputStream> v = 
                new Vector<ByteArrayInputStream>();
        v.add(in);
        v.add(in2);

        Enumeration<ByteArrayInputStream> ele = v.elements();

        //创建一个SequenceInputStream对象(SequenceInputStream ins = new SequenceInputStream(in, in2);亦可)
        SequenceInputStream ins = new SequenceInputStream(ele);

        FileOutputStream out = new FileOutputStream("to.txt");

        //ins读数据，out写数据。out将ins读的数据写入to.txt中
        int len;

        while ((len=ins.read())!=-1) {
            out.write(len);
        }

        //释放资源
        ins.close();
        out.close();
    }
}

7、PipedInputStream&PipedOutputStream

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;
import java.io.PrintStream;

/**
 * @author Hanlin Wang
 */

public class PipedStream {
    public static void main(String[] args) throws Exception{
        final PipedInputStream in = new PipedInputStream();
        final PipedOutputStream out = new PipedOutputStream();

        //连接
        in.connect(out);

        //包装out，用于向in写入数据
        final PrintStream printer = new PrintStream(out);

        //从键盘中获取数据
        final BufferedReader data = new BufferedReader(
                new InputStreamReader(System.in));

        //reader包装in，用于获取数据
        final BufferedReader reader = new BufferedReader(
                new InputStreamReader(in));

        //创建写线程
        new Thread(new Runnable() {
            public void run() {
                //将数据写入out
                while (true) {
                    try {
                        String line = data.readLine();
                        System.out.println(Thread.currentThread().getName() + "，发送信息："+line);
                        System.out.println("\n发送中...\n");
                        Thread.sleep(5000);
                        printer.println(line);
                    } catch (IOException e) {
                        e.printStackTrace();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }, "服务端线程").start();

        //创建读线程
        new Thread(new Runnable() {
            public void run() {
                while (true) {
                    try {
                        System.out.println(Thread.currentThread().getName()+"，收到信息："+reader.readLine());
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }, "客户端线程").start();
    }
}

8、PrintStream

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

/**
 * @author Hanlin Wang
 */

public class PrintStream_ {
    public static void main(String[] args) throws Exception{
        FileOutputStream out = new FileOutputStream("to.txt");
        PrintStream printer = new PrintStream(out);

        //创建一个对象
        Person p = new Person("李四", 24);

        //写入to.txt，
        printer.println(p);
        printer.print("Hello, it's me");

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

字符流

1、FileReader&FileWriter

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

/**
 * @author Hanlin Wang
 */

public class FileReaderAndWriter {
    public static void main(String[] args) throws IOException {
        FileReader reader = new FileReader("from.txt");

        //1024大小的字符数组
        char[] buf = new char[1024];

        //reader读取字符，将读取的字符存入buf中。len为读取的字符数。
        int len = reader.read(buf);

        //读取完毕后。释放资源
        reader.close();

        //打印读取的信息
        String str = new String(buf, 0, len);
        System.out.println();

        FileWriter writer = new FileWriter("to.txt");

        //将读取的信息写入to.txt
        writer.write(str);

        //写入完成后，释放资源
        writer.close();
    }
}

2、BufferedReader&BufferedWriter

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;

/**
 * @author Hanlin Wang
 */

public class BufferedReaderAndWriter {
    public static void main(String[] args) throws Exception{
        BufferedReader test = new BufferedReader(new FileReader("from.txt"));

        //BufferedReader中有一个readLine方法，返回一行字符串。循环打印
        String line = null;
        while ((line=test.readLine())!=null) {
            System.out.println(line);
        }

        BufferedReader reader = new BufferedReader(new FileReader("from.txt"));

        char[] buf = new char[1024];

        //len为写入到buf的字符数
        int len = reader.read(buf);

        //读取完成了，释放资源
        reader.close();

        //通过buf字符获取字符串
        String str = new String(buf, 0, len);

        BufferedWriter writer = new BufferedWriter(new FileWriter("to.txt"));

        //写入数据到to.txt
        writer.write(str);

        //写入完成后，释放资源
        writer.close();
    }
}

3、CharArrayReader&CharArrayWriter

import java.io.CharArrayReader;
import java.io.CharArrayWriter;
import java.io.FileWriter;

/**
 * @author Hanlin Wang
 */

public class CharArrayReaderAndWriter {
    public static void main(String[] args) throws Exception{
        //输入流，通过构造函数获得原始数据
        CharArrayReader reader = new CharArrayReader("u make me wanna".toCharArray());

        //输出流，没有目的地，写入输入流的数据到自己本身
        CharArrayWriter writer2 = new CharArrayWriter();

        //writer将reader中的数据写入到自己本身，reader先读取自己的数据，复制给一个局部变量len
        int len;

        while ((len=reader.read())!=-1) {
            writer2.write(len);
        }

        //释放资源
        reader.close();

        writer2.close();

        FileWriter writer = new FileWriter("to.txt");

        //将writer2转换为字符数组，然后writer写入之（转换为字符串也可以）
        writer.write(writer2.toCharArray());//writer2.toString()亦可

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

4、PipedReader&PipedWriter

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PipedReader;
import java.io.PipedWriter;
import java.io.PrintWriter;

/**
 * @author Hanlin Wang
 */

public class PipedReaderAndWriter {
    public static void main(String[] args) throws Exception{
        final PipedReader reader2 = new PipedReader();
        final PipedWriter writer = new PipedWriter();

        //连接
        reader2.connect(writer);

        //读取键盘数据
        final BufferedReader keyboard = new BufferedReader(
                new InputStreamReader(System.in));

        //pw包装writer
        final PrintWriter pw = new PrintWriter(writer);

        //reader包装reader2，便于用readLine()方法读取pw写入的数据
        final BufferedReader reader = new BufferedReader(reader2);

        //写数据线程
        new Thread(new Runnable() {
            public void run() {         
                while (true) {
                    try {
                        String line = keyboard.readLine();
                        System.out.println(Thread.currentThread().getName()
                                + "，发送数据：" + line);
                        System.out.println("\n发送中...\n");
                        Thread.sleep(3000);
                        pw.println(line);
                    } catch (IOException e) {
                        e.printStackTrace();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }, "服务端线程").start();

        //读数据线程
        new Thread(new Runnable() {
            public void run() {
                while (true) {
                    try {
                        System.out.println(Thread.currentThread().getName()
                                + "，收到数据："+reader.readLine());
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }, "客户端线程").start();
    }
}

5、PrintWriter

import java.io.CharArrayReader;
import java.io.CharArrayWriter;
import java.io.FileWriter;
import java.io.PrintWriter;

/**
 * @author Hanlin Wang
 */

public class PrintWriter_ {
    public static void main(String[] args) throws Exception{
        CharArrayWriter writer = new CharArrayWriter();

        PrintWriter pw = new PrintWriter(writer);

        pw.println("hahaha");

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

        CharArrayReader reader = new CharArrayReader(writer.toCharArray());

        int len;

        while ((len=reader.read())!=-1) {
            System.out.print((char)len);
        }

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

6、StringReader&StringWriter

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

/**
 * @author Hanlin Wang
 */

public class StringReaderAndWriter {
    public static void main(String[] args) throws Exception{
        StringWriter writer = new StringWriter();

        writer.write("whataya want from me");

        writer.close();

        StringReader reader = new StringReader(writer.toString());

        int len;

        while ((len=reader.read())!=-1) {
            System.out.print((char)len);
        }//System.out.println(writer.toString());

        reader.close();
    }
}