IO流

1.InputStream 

　　InputStream是一个抽象类，是字节流的基类。

示例1：

public void testInputSteam() throws IOException
    {
        //1.创建文件流
        InputStream input=new FileInputStream("abc.txt");
        
        //2.读取文件内容
        byte [] buffer=new byte[10];
        int len=0;
        //read(byte[] b)返回每次读取的字节个数。如果到达流的末尾，则返回-1；
        while ((len=input.read(buffer))!=-1)
        {
            for(int i=0;i<len;i++)
            {
                System.out.print((char)buffer[i]);
            }
            
        }

        //3.关闭文件流，这一步千万别忘记。程序中打开的文件 IO 资源不属于内存里的资源，垃圾回收机制无法回收该资源，所以应该显式关闭文件 IO 资源。
        input.close();
    }

示例2：

public void testInputSteam2() throws IOException
    {
        //1.创建文件流
        InputStream input=new FileInputStream("abc.txt");
        
        //2.读取文件内容
        byte [] buffer=new byte[1024*10];

        //read(byte[] b, int off, int len):从off位置开始读取len长度到b数组中
        input.read(buffer, 0, input.available());
        for(int i=0;i<buffer.length;i++)
            System.out.print((char)buffer[i]);

        //3.关闭文件流
        input.close();
    }

2.Reader

　　Reader是一个抽象类，是字符流的基类。

示例1：

        public void testReader() throws IOException
    {
        //1.创建文件流
        Reader reader=new FileReader("hello.txt");
        
        //2.读取文件内容
        char [] buffer=new char[10];
        int len=0;
        while( (len=reader.read(buffer))!=-1 )
        {
            for(int i=0;i<len;i++)
            {
                System.out.print(buffer[i]);
            }
        }
        
        //3.关闭文件流
        reader.close();        
    }    

 3.OutputStream

示例1：

        /*
     * 将文件a的内容复制到文件b中
     */
    @Test
    public void testOutputStream() throws IOException
    {
        /*1.新建一个指向文件a的输入流*/
        InputStream in=new FileInputStream("abc.txt");
        /*2.新建一个指向文件b的输出流*/
        OutputStream out=new FileOutputStream("abc2.txt");
        /*3.将从文件a读取的内容输出到文件b中*/
        byte [] buffer=new byte[1024 *10];    
        int len=0;
        while( (len=in.read(buffer)) !=-1)
        {
            out.write(buffer, 0, len);
        }
        /*4.关闭输入流，输出流*/
        in.close();
        out.close();
    }    

4.Writer

示例1：

        /*
     * 利用字符流完成两个文件的复制
    */
    @Test
    public void testWriter() throws IOException
    {
        //新建输入流
        Reader reader=new FileReader("abc.txt");
        //新建输出流
        Writer writer=new FileWriter("abc3.txt");
        
        char [] buffer=new char[10];
        int len=0;
        //从a文件中读出数据放入缓冲数组中，再将该字符数组写入到b文件
        while((len=reader.read(buffer)) !=-1)
        {
            //注意使用的方法是wirte(char[] b,int offset,int len),而不是wirte(char[] b),否则最后一次写入是会超出
            writer.write(buffer, 0, len);
        }
        //关闭输入流，输出流
        reader.close();
        writer.close();
        
    }    

5.BufferedReader和BufferedWriter

示例1：

public void testBufferedReaerAndBufferedWriter() throws IOException
    {
        //1.新建缓冲输入流，缓冲输出流
        Reader reader=new FileReader("abc.txt");
        //BufferedReader(Reader in):BufferedReader对象需要通道一个Reader对象创建
        BufferedReader bufferedReader=new BufferedReader(reader);
        
        Writer writer=new FileWriter("abc4.txt");
        BufferedWriter bufferedWriter=new BufferedWriter(writer);
        //2.利用readLine()方法读取文件的中一行，并写入输出文件中，直至文件结束。
        String str=null;
        int i=0;
        while( (str=bufferedReader.readLine()) != null)
        {
            //注意：readLine()读取每一行的字符内容不包括换行符，所以使用该方法要记得手动加换行符
            if(i!=0)
            {
                writer.write("
");
            }
            writer.write(str);
            i++;
        }
        
        //3.关闭缓冲输入流，缓冲输出流。直接关闭包装类，函数内部自动关闭节点流
        bufferedReader.close();
        bufferedWriter.close();
    }

6.BufferedInputStream和BufferedOutputStream

示例1：

public void testBufferedInputStreamAndBufferedOutputStream() throws IOException
    {
        InputStream in=new FileInputStream("abc.txt");
        BufferedInputStream bufferedInputStream=new BufferedInputStream(in);
        
        OutputStream out=new FileOutputStream("abc5.txt");
        BufferedOutputStream bufferedOutputStream=new BufferedOutputStream(out);
        
        byte[] buffer=new byte[10];
        int len=0;
        while( (len=bufferedInputStream.read(buffer))!=-1)
        {
            bufferedOutputStream.write(buffer, 0, len);
        }
        
        bufferedInputStream.close();
        bufferedOutputStream.close();
    }

7.InputStreamReader和InputStreamWriter 转换流

InputStreamReader：将输入字节流转换为字符流

InputStreamWriter：将输出字节流转换为输出字符流

8.RandomAcessFile

RandomAcessFile类既可读又可写。RandomAcessFile支持随机访问的模式，程序可以通过文件指针跳到任意位置读写。所以如果需要处理比较复杂的文件操作时，可以使用该类比较方便

是独立于其他IO流的，直接继承于Object类。

示例1：

    /*
     * 在文件的第二行添加It is a sunny day!
    */
    @Test
    public void testRandomAccess() throws IOException
    {
        //1.RandomAccessFile(File file, String mode)，创建从中读取和向其中写入（可选）的随机访问文件流
        RandomAccessFile randomAccessFile=new RandomAccessFile("abc.txt", "rw");
        
        //2.读取文件内容，添加新行
        //先读取第一行，然后将后面部分读入到一个数组中，添加新行，再把原文件第二行至末尾放入新文件中（只适用于文件不大的情况）
        //2.1 先读取第一行
        String line=randomAccessFile.readLine();
        byte[] buffer=new byte[1024];
        //2.2 将第一行后面的内容读取到数组中
        randomAccessFile.read(buffer);
        //2.3 将文件指针重新定位到文件第一行后面
        randomAccessFile.seek(line.length());
        //2.4 写入新内容和剩下部分
        randomAccessFile.writeBytes("
It is a sunny day
");
        randomAccessFile.write(buffer);
        
        //3.关闭文件流
        randomAccessFile.close();        
    }