IO流

首先开篇立论 什么是IO流：设备之间的数据传输。java中对于数据的输入(input)/输出(output)操作以”流(stream)” 的方式进行，所以就叫IO流
但是在记输入/输出流之前，先记一个类：File类
File类能创建，删除，重命名文件和目录，但是不能修改（访问）文件本身的内容，要修改问价的内容还得需要输入/输出流
File对象可以作为参数传递给流的构造函数
常用的构造方法
public File(String pathname）
public File(String parent,String child) parent为父路径，child为子路径创建File对象
注释：系统路径分隔符，在UNIX中，此字段为‘/’，在Windows中，为‘\\’
举个例子

```package ligang.com;import java.io.File;public class FileTset {public static void main(String[] args) {    File file=new File("Hello World.txt ");//文件放在项目的目录文件夹下0   File file1 =new File("D\\AAA","1.txt");//文件放在指定的“D:AAA”目录中}}

在写IO流之前，我先把什么叫输入（input）/输出（output）
看图

文件是由字符或字节构成的，在此基础上再分为输入流/输出流的
所有的文件类都是在这个四个基类的基础上扩展继承的
看图

FileInputStream(文件字节输入流)
FileOutputStream(文件字节输出流)
FileReader(文件字符输入流)
FileWriter(文件字符输出流）
来个例子

package ligang.com;import java.io.File;import java.io.FileInputStream;import java.io.FileNotFoundException;import java.io.FileOutputStream;import java.io.FileReader;import java.io.FileWriter;import java.io.IOException;import java.io.Reader;import java.io.Writer;import org.omg.CORBA.PUBLIC_MEMBER;public class FileText {    public static void main(String[] args) {        //FileOutputStream文件字节输出流        File file1=new File("Hello World");//创建文件        FileOutputStream fos=null;//定义字节文件容器，刚开始为空        try {            fos=new FileOutputStream(file1);            byte [] b="i love my home i love my china".getBytes();            fos.write(b);//向文件容器中写入数据        } catch (Exception e) {        e.printStackTrace();        }        finally {            try {                fos.close();//gc进程管不了文件，所以文件得自己回收            } catch (IOException e) {                e.printStackTrace();            }        }        //FileInputStream(文件字节输入流)        File file=new File("Hello World");        //将此File类的对象作为形参传递给InputStream的构造器中        FileInputStream fis=null;        try {            fis = new FileInputStream(file);            int i;            //通过调用read（）方法将文件中的数据读入        while((i=fis.read())!=-1){            System.out.print((char)i);            }        }catch (IOException e) {            e.printStackTrace();        }finally {            try {                //关闭现有的流                fis.close();            } catch (IOException e) {                e.printStackTrace();            }        }        //FileWriter输入字符流        Writer w=null;        try {            w=new FileWriter("1.txt");            w.write("what's,your name?");        } catch (IOException e1) {            e1.printStackTrace();        }        finally{            try {                w.close();            } catch (IOException e) {                e.printStackTrace();            }        }        //FileReade输出字符流        Reader r = null;        try {            r = new FileReader("1.txt");            System.out.println();            int b = 0;            while ((b = r.read()) != -1) {                //输出字符                System.out.print((char)b);            }        }catch(FileNotFoundException e) {            e.printStackTrace();        }catch(IOException e) {            e.printStackTrace();        }finally {            try {                if (r != null)  {                    r.close();                  }            }catch(IOException e) {}            }    }    }    显示结果    i love my home i love my china    what's,your name?

缓冲流
主要是为了提高效率而存在的，减少物理读取次数
主要有
BufferedInputStream
BufferedOutputStream
BufferedReader
BufferedWriter
BufferedReader提供了实用方法readLine()，可以直接读取一行，BufferWriter提供了newLine()可以写换行符。

多记点点：为什么说缓冲流会提高效率
采用BufferedInputStream对InputStream进行装饰，BufferedInputStream会将数据先读到缓存里，Java程序再次读取数据时，直接到缓存中读取，减少Java程序物理读取的次数，提高性能
采用BufferedOutputStream对FileOutputStream进行装饰，每次写文件的时候，先放到缓存了，然后再一次性的将缓存中的内容保存到文件中，这样会减少写物理磁盘的次数，提高性能
其他的同理可证^_^！！！
看代码

package ligang.com;import java.io.*;import org.omg.CORBA_2_3.portable.OutputStream;public class Bufferd {public static void main(String[] args) {/* * 用BufferedInputStream与BufferedOutputStream实现文件的快速复制 */    InputStream is=null;    OutputStream os=null;    try {        BufferedInputStream fis=new BufferedInputStream(new FileInputStream("1.txt"));        BufferedOutputStream fos=new BufferedOutputStream(new FileOutputStream("1.txt.bak"));        int b = 0;        try {            while ((b =fis.read()) != -1) {                fos.write(b);            }            fos.flush();            System.out.println("文件复制完毕！！");        } catch (IOException e) {            e.printStackTrace();        }        finally {            try {                if(fos!=null)                fos.close();                if(fis!=null)                    fis.close();            } catch (IOException e) {                e.printStackTrace();            }        }    } catch (FileNotFoundException e) {        e.printStackTrace();    }    /**     * 用BufferedReader与BufferedWriter实现文件的快速复制     */    BufferedReader is1 = null;    BufferedWriter os1= null;    try {        is1= new BufferedReader(new FileReader("Hello World"));        os1= new BufferedWriter(new FileWriter("12.txt"));        String s = null;        while ((s = is1.readLine()) != null) {            os1.newLine();            os1.write(s);            //可以采用如下方法换行            os1.newLine();        }        System.out.println("文件复制完毕！");    }catch(FileNotFoundException e) {        e.printStackTrace();    }catch(IOException e) {        e.printStackTrace();    }finally {        try {            if (is1 != null)    {                is1.close();                }            if (os1!= null) {                //在close前会先调用flush                os1.close();                }        }catch(IOException e) {            e.printStackTrace();        }       }}}

简单的复制操作，一个用缓冲字节流实现，一个用缓冲字符流实现，很简单的操作，却让我摸了好久。。。。
转换流：InputStreamReader主要是将字节流输入流转换成字符输入流
OutputStreamWriter主要是将字节流输出流转换成字符输出流

举个小例子

package ligang.com;import java.io.*;import javax.activation.FileDataSource;public class zhuanhuanliu {    /**     * 将字节流输入流转换成字符输入流     */    public static void main(String[] args) {        BufferedReader fis=null;        try {            fis=new BufferedReader(                     new InputStreamReader(                             new FileInputStream("12.txt")));//首先取得输入字节流，再转成输入字符流，最后转换成输出字符缓冲流            String s=null;        try {            while((s=fis.readLine())!=null){                System.out.println(s);            }        } catch (IOException e) {            e.printStackTrace();        }                } catch (FileNotFoundException e) {            e.printStackTrace();        }        finally{            try {                if(fis!=null)                fis.close();            } catch (IOException e) {                e.printStackTrace();            }        }        /**         * 将字节流输出流转换成字符输出流         */        BufferedWriter fis0 = null;        try {            fis0=new BufferedWriter(                         new OutputStreamWriter(                                 new FileOutputStream("1.txt")));//首先取得字节输出流，再转成字符输出流，最后转成字符缓冲输出流            try {                fis0.write("my name is xiao ganggang");                fis0.newLine();                fis0.write("nice to me to you!");            } catch (IOException e) {                e.printStackTrace();            }        } catch (FileNotFoundException e) {            e.printStackTrace();        }        finally{    try {        if(fis0!=null)        fis0.close();    } catch (IOException e) {        e.printStackTrace();    }        }    }}

System.out其实对应的就是PrintStream，默认输出到控制台，我们可以重定向它的输出，可以定向到文件，也就是执行System.out.println()不输出到屏幕，而输出到文件
举个小例子

package ligang.com;import java.io.*;import javax.activation.FileDataSource;public class rou {    public static void main(String[] args) {        OutputStream os = null;        try {            os=new FileOutputStream("1.txt");            System.setOut(new PrintStream(os));`//将输出改为指定的文件`            System.out.println("世界你好，世界午安！！");        } catch (FileNotFoundException e) {            e.printStackTrace();        }finally {            try {                if (os!=null) {                    os.close();                }            } catch (IOException e) {                e.printStackTrace();            }        }    }}

也可以将屏幕的输入到文件中
举个小例子

package ligang.com;import java.io.*;import javax.activation.FileDataSource;public class rou {    public static void main(String[] args) {        OutputStream os1 = null;        BufferedReader os = null;        try {            os1=new FileOutputStream("1.txt");            System.setOut(new PrintStream(os1));//将输出改为指定的文件        } catch (FileNotFoundException e1) {            e1.printStackTrace();        }        os=new BufferedReader(                new InputStreamReader(System.in));//将从键盘得到数据放到指定文件中        String s=null;        try {            while((s=os.readLine())!=null){                System.out.println(s);//这里相当与本是输出到终端的，但现在输出到os1的文件中去                if("w".equals(s))                    break;              }        } catch (IOException e) {            e.printStackTrace();        }               finally {            try {                if(os!=null)                os.close();                if(os1!=null)                    os1.close();            } catch (IOException e) {                e.printStackTrace();            }        }    }}

还有对象流。。貌似有点多了，
对象流可以将Java对象转换成二进制写入磁盘，这个过程通常叫做序列化，并且还可以从磁盘读出完整的Java对象，而这个过程叫做反序列化。
对象流主要包括：ObjectInputStream和ObjectOutputStream

而实现序列化和反序列化，就需要实现java.io.Serializable 接口，但他没有任何方法，只是一种标记接口
我不想写了。。。
到这儿