IO (Input Output)流

IO流用来处理设备之间的数据传输；

JAVA对数据的操作是通过流的方式；

JAVA对于操作流的对象都在IO包中；

流按操作数据分为两种：字节流和字符流；

流按流向分为输入流和输出流。


IO流常用基类

字节流的抽象基类：

InputStream ，OutputStream

字符流的抽象基类：

Reader , Writer

注：由这4个类派生出的子类名称都是以其父类名作为子类明的后缀。

如：InputStream 的子类 FileInputStream。

如：Reader 的子类 FileReader。


既然IO流是用于操作数据的，

那么数据最常见的体现形式是：文件。

需求：在硬盘上，创建一个文件并写入一些文字数据。

找到一个专门操作文件的Writer子类对象。FileWriter。后缀名是父类名，前缀名是该流对象的功能。

import java.io.*;

class FileWriterDemo
{
    public static void main(String[] args) throws IOException
    {
        //创建一个FileWriter对象。该对象一被初始化就必须要明确被操作的文件。
        //该文件会被创建到指定的目录下。如果该目录下已有同名文件，将被覆盖。
        //其实该步骤就是在明确数据要存放的目的地。
        FileWriter fw = new FileWriter("D:\\test.txt");

        //调用write方法，将字符串写入到流中。
        fw.write("abcdfeg");

        //刷新流对象中的缓冲区中的数据。
        //将数据刷新到目的地中。
        fw.flush();

        //关闭流资源，但是在关闭之前会刷新一次内部的缓冲中的数据，将数据刷新到目的地。
        //和flush的区别：flush刷新之后，流可以继续使用，close刷新后，将会关闭流。
        fw.close();
    }
}


对流的异常操作

import java.io.*;

class FileWriterDemo2
{
    public static void main(String[] args)
    {   
        //把变量放在try代码块外面，这样在finally代码块环境中也能使用 
        FileWriter fw = null;
        try
        {
            fw = new FileWriter("k:\\text.txt");
            fw.write("aaaaaaa");
        }
        catch(IOException e)
        {
            System.out.println(e.toString());
        }
        finally
        {
            try
            {
                //判断资源对象是否存在
                if(fw != null)
                fw.close();
            }
            catch(IOException e)
            {
                System.out.println(e.toString());
            }
            
        }
        
    }
}

读取文件内容

import java.io.*;

class FileReaderDemo
{
    public static void main(String[] args) 
    {
        FileReader fr = null;
        try
        {
            fr = new FileReader("D:\\test.txt");
            int ch = 0;
            while((ch=fr.read()) != -1)
            {
                System.out.print((char)ch);
            }
        }
        catch(IOException e)
        {
            System.out.println(e.toString());
        }
        finally
        {
            try
            {
                if(fr != null)
                fr.close();
            }
            catch(IOException e)
            {
                System.out.println(e.toString());
            }   
        }  
    }
}

用数组参数读取文件

import java.io.*;

class FileReaderDemo2
{
    public static void main(String[] args) throws IOException
    {
        FileReader fr = null;
        try
        {
            fr = new FileReader("F:\\java\\FileReaderDemo.java");
            char[] buf = new char[1024];//创建一个临时数组
            int num = 0;
            while((num = fr.read(buf)) != -1)//把读取的数据存入字符数组中
            {
                System.out.print(new String(buf,0,num));//把数组转成字符串并且打印出来
            }
        }
        catch(IOException e)
        {
            System.out.println(e.toString());
        }
        finally
        {
            try
            {    
                if(fr != null)
                fr.close();
            }
            catch(IOException e)
            {
                System.out.println(e.toString());
            }
        }
    }
}


文件的拷贝：

import java.io.*;

class FileCopyDemo2
{
    public static void main(String[] args)
    {
        copy();
    }

    public static void copy()
    {
        FileWriter fw = null;
        FileReader fr = null;
        try
        {
            fw = new FileWriter("F:\\java\\xin.txt",true);   //创建输入流
            fr = new FileReader("F:\\java\\new.txt");    //创建输出流

            char[] buf = new char[1024];    //定义容器
            int len = 0;      //定义长度

            while((len=fr.read(buf)) != -1)
            {
                fw.write(buf,0,len); //把字符数组中的内容存入指定区域
            }

        }
        catch(IOException e)
        {
            System.out.println(e.toString());
        }
        finally
        {
            try
            {
                if(fw != null)
                    fw.close();
            }
            catch(IOException e)
            {
                System.out.println(e.toString());
            }
            finally
            {    
                try
                {
                    if(fr != null)
                    fr.close();
                }
                catch(IOException e)
                {
                    System.out.println(e.toString());
                }
                
            }

        }
    }
}


字符流的缓冲区

缓冲区的出现提高了对数据的读写效率；

对应类

BufferedWriter , BufferedReader

缓冲区要结合流才能使用；

在流的基础上对流的功能进行了增强。


利用缓冲的文件拷贝

import java.io.*;

class BufferedCopyDemo
{
    public static void main(String[] args) throws IOException
    {
        BufferedWriter bufw = null;
        BufferedReader bufr = null;

        try
        {
            bufw = new BufferedWriter(new FileWriter("FileWriterDemo_copy.txt"));
            bufr = new BufferedReader(new FileReader("FileWriterDemo.java"));

            String line = null;
            while((line = bufr.readLine()) != null)
            {
                bufw.write(line);
                bufw.newLine();
            }
        }
        catch(IOException e)
        {
            System.out.println(e.toString());
        }
        finally
        {
            try
            {
                if(bufr != null)
                    bufr.close();
            }
            catch(IOException e)
            {
                System.out.println(e.toString());
            }

            try
            {
                if(bufw != null)
                    bufw.close();
            }
            catch(IOException e)
            {
                System.out.println(e.toString());
            }
        }
    }
}