Javase-I/O

1.基础流：

1. 字节流：
   1. 文件流：FileInputStream, FileOutputStream
   2. 字节数组流：ByteArrayInputStream, ByteArrayOutputStream
2. 字符流：
   1. 文件流：FileReader, FileWriter
   2. 字符数组流：CharArrayReader, CharArrayWriter

2.修饰流：

1. 字节流：
   1. 缓冲：BufferedInputStream, BufferedOutputStream
2. 字符流：
   1. 缓冲：BufferedReader, BufferedWriter

下面逐个测试：

FileInputStream, FileOutputStream

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.io.StringBufferInputStream;


public class FileStream {

    public static void main(String[] args) throws IOException
    {
        //测试FileInputStream,FileOutputStream
        FileInputStream fis = new FileInputStream("file.txt");
        FileOutputStream fos = new FileOutputStream("file1.txt");
        
        byte[] bytes = new byte[fis.available()];
        
        fis.read(bytes);
        fos.write(bytes);
        
        String s;
        s = new String(bytes);
        System.out.println(s);
        
    }

}

这里bis从文件file.txt按字节读取文件内容到字节数组bytes，bos将字节数组写入file1.txt文件，并在控制台输出。

ByteArrayInputStream, ByteArrayOutputStream:

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


public class ByteStreamTest {

    public static void main(String args[])
    {
        //测试ByteArrayOutputStream
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        //289截断到一个字节后二进制为0000 0033，对应的ascii字符为'!'
        //原型为write(int),将289写入到字节数组
        baos.write(289);
        
        byte[] b = baos.toByteArray();
        System.out.println(b.length);
        //这里字节又被强转为两个字节的char类型，二进制为0000 0000 0000 0033
        System.out.println((char)b[0]);
        
        ByteArrayInputStream bais = new ByteArrayInputStream(b);
        //这里read()将1个字节0000 0033转为整型返回，之后又强转为char
        char c = (char) bais.read();
        System.out.println(c);
    }
}

ByteArrayOutputStream中有字节缓冲,这里将289写入一个字节，发生截断，使用baos.toByteArray()取出字节数组，打印其长度为1，用该字节数组初始化ByteArrayInputStream,从bais取出该字节数组中的一个字节，强转为char类型，33对应的assci码为！，所以输出!。

1
!
!

FileReader, FileWriter

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


public class FileReaderWriterTest {
    public static void main(String args[]) throws IOException
    {
        FileReader fr = new FileReader("file.txt");
        char[] s1 = new char[100];
        //按字符也就是两个字节读入到字节数组
        fr.read(s1);
        for (int i = 0; i < s1.length; i++)
            System.out.print(s1[i]);

        
        char[] s2 = {'你', '好'};
        FileWriter fw = new FileWriter("fileTo.txt");
        //将字符数组写入到文件
        fw.write(s2);
        
        //关闭文件，刷新缓冲区
        fw.close();
        fr.close();

        
     }

}

fr从file.txt读取内容到字符数组，并将其打印，fw将字符数组写入文件fileTo.txt。

CharArrayReader, CharArrayWriter

import java.io.CharArrayReader;
import java.io.CharArrayWriter;
import java.io.IOException;


public class CharArrayReaderWriterTest {

    public static void main(String[] args) throws IOException
    {
        CharArrayWriter caw = new CharArrayWriter();
        
        char[] c = {'字', '符', '数', '组'};
        //将字符数组写入缓冲区
        caw.write(c);
        //获取字符数组
        char[] cc = caw.toCharArray();
        String s = new String(cc);
        System.out.println(s);
        
        //使用字符数组c构造CharArrayReader
        CharArrayReader car = new CharArrayReader(c);
        int a;
        //读取每个字符
        while ( (a = car.read()) != -1)
        {
            System.out.println((char)a);
        }
        
    }
}

输出：

字符数组
字
符
数
组

BufferedInputStream, BufferedOutputStream:

public class BufferedStream {

    public static void main(String args[]) throws IOException
    {
        //修饰流，需要由InputStream,OutputStream构造,本质上还是按字节读入写出，但是增加了缓冲
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("file.txt"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("fileTo.txt"));
        
        int bytesCount = 0;
        int a;
        while ( (a = bis.read()) != -1)
        {
            bytesCount++;
            bos.write(a);
        }
        System.out.println("读取的字节数:"+bytesCount);
        
        
        //记得关闭流，刷新缓冲区
        bis.close();
        bos.close();
    }
}

BufferedInputStream, BufferedOutputStream是修饰流，还是按字节读取，增加了缓冲机制，这是实现了按字节将file.txt的内容复制到fileTo.txt中。

BufferedReader, BufferedWriter:

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


public class BufferedReadWriterTest {

    public static void main(String args[]) throws IOException
    {
        BufferedWriter bw = new BufferedWriter(new FileWriter("file.txt"));
        BufferedReader br = new BufferedReader(new FileReader("file.txt"));
        
        bw.write("第一行
");
        bw.write("第二行
");
        bw.write("第三行
");
        bw.flush();
        
        
        String s;
        while ( (s = br.readLine()) != null)
        {
            System.out.println(s);
        }
        
        br.close();
        bw.close();
        

        
    }
}

BufferedReader, BufferedWriter是修饰流，提供按行读取的功能，这里向文件写入三行数据，然后按行读取。

第一行
第二行
第三行