黑马程序员——java-IO流

———–android培训、java培训、java学习型技术博客、期待与您交流！————

1
IO流(掌握)

(1)IO流的作用：上传文件和下载文件。

    上传文件：        数据源：本地        目的地：服务器    下载文件：        数据源：服务器        目的地：本地

---

(2)IO流的分类：

    A:流向        输入流 读取数据        输出流 写出数据    B:数据类型        字节流            字节输入流            字节输出流        字符流            字符输入流            字符输出流    一般来说，如果没有说明按照哪种类型分，指的是按照数据类型分。

(3)什么时候使用字符流,什么时候使用字节流。
如果一个要操作的文件，通过记事本打开并能够读懂其内容，就可以考虑使用字符流。否则，就使用字节流。什么都不知道，就用字节流。
(4)IO的基类及具体类
IO

    |--字节流            字节输入流                InputStream（抽象类）                    --FileInputStream            字节输出流                OutputStream（抽象类）                    FileOutputStream     |--字符流            字符输入流                Reader（抽象类）                    FileReader            字符输出流                Writer（抽象类）                    FileWriter

2
（1）FileWriter写数据的步骤及代码体现：

FileWriter 的构造方法        --FileWriter(String fileName)//            注意，参数可以只是一个文件名，则是在本建文件（也就是在workspace中创建）也可是是一个绝对路径，那就就在这个绝对路径下创建该文件        --public FileWriter(File file)//把路径封装成一个file对象传进来        --public FileWriter(File file，String name)

public class Io2{    /*从程序向文件中写数据，步骤     * A:创建字符输出流对象。       B:调用write方法。       C:释放资源。    */    public static void main(String[] args) throws IOException    {        //A:创建字符输出流对象。        FileWriter fw=new FileWriter("a.txt");        //B:调用write方法。        fw.write("你好。该吃饭了");        fw.flush();//刷新缓冲区        fw.close();//释放资源    }}

几个要注意的小问题：

        A:创建字符输出流对象做了哪些事情?           --调用系统功能，创建一个名字为a.txt的文件           --创建一个输出流对象fw           --把这个流对象指向此文件        B:为什么要刷新缓冲区?        因为我们使用的是字符流对象，而数据的底层用的字节流实现的（1字符=2字节），        即，底层在读取数据的时候是每次只能读取一个字节，每个字符的输出都要用到缓冲区，        只有把缓冲区刷新，才能把字符拿到        C:为什么要释放流资源?        fw.close();        作用            --关闭流对象，流对象就是垃圾            --通知操作系统去释放和开始创建的那个文件相关的资源        释放资源，首先会自动调用一次fw.flush(),保证数据不丢失        而后,流对象就是垃圾，不能再使用，        D:刷新和释放有什么区别?         fw.flush();刷新后，还可以继续使用流对象进行相关的操作          fw.close();释放后，流对象就是垃圾，不能再使用了        E:如何实现数据的换行?        fw("\n");        F:如何实现数据的追加写入?        使用带参数的构造方法        public FileOutputStream(String name,boolean append)        FileWriter fw=new FileWriter("java.txt",true);        这样在用对象调用write（）方法的时候，不是覆盖数据，而是从该文件的末尾开始 追加数据

（2）FileReader读数据的步骤及代码体现：

   构造方法：    ----public FileReader(File file)    ----public FileReader(String fileName)    参数是一个已经存在的文件的名字

public class IO3{    /*1 创建输入流对象     *2 调用Read（）方法     *3 释放资源     *      */    public static void main(String[] args) throws IOException    {        //1 创建输入流对象        //从该文件读取数据到程序中，所以前提必须是该文件存在        FileReader fr=new FileReader("java.txt");        //2 调用read（）方法        //read()此方法返回的是java.txt文件中，对应字符的ＡＳＣＩＩ值,read（）方法的返回值是一个int类型的数，当返回值为-1的时候说明以及读到该文件的结尾，----------//这是第一种读取数据方法：一次只读一个字节    int leng=0;        while((leng=fr.read())!=-1)        {            System.out.println((char)leng);            //把int类型强转为字符类型        }----------//这是第二种读取数据的方法：一次读一个字符数组        char[] ch=new char[1024];        int leng=0;        while((leng=fr.read(ch))!=-1)        {            System.out.println(String.valueOf(ch, 0, leng));        }    }}

（3）复制文本数据：

public class IO{//复制文件    public static void main(String[] args) throws IOException    {        //创建输入流对象（字节流）        InputStream ip=new FileInputStream("java.txt");        //创建输出流对象        OutputStream op=new FileOutputStream("b.txt");----------方法一：一次读一个字符：//      int leng=0;//      while((leng=ip.read())!=-1)//      {//          op.write(leng);//          //      }----------方法二：一次读一个字符字符数组：        byte[] bys=new byte[1024];        int leng=0;        while((leng=ip.read(bys))!=-1)        {            op.write(bys);        }        ip.close();        op.close();    }}

3
高效流(掌握)//只是提供高效的操作，底层的读写，还是靠基本操作流

(1)字符高效流
BufferedReader–输入流

       构造方法--BufferedReader(Reader in)

BufferedWriter—输出流

      构造方法-- public BufferedWriter(Writer out)

高效流的读操作，也和上边一样，有两种方法
一次读一个字符和一次读一个字符数
但是，需要注意的是，
BufferedReader有一个特有的方法

String readLine()//一次读一行数据，，注意，该方法不读换行字符

BufferedWriter也有一个特有的方法

 void newLine()//系统自自己分配换行

public class IO4{    public static void main(String[] args) throws IOException    {        //创建高效输入流对象和高效输出流对象(字符流)        BufferedReader br=new BufferedReader(new FileReader("java.txt"));        BufferedWriter bw=new BufferedWriter(new FileWriter("c.txt"));        //先从java.txt中读取文件数据在向c.txt中写入数据        String leng=null;        while((leng=br.readLine())!=null)        {            bw.write(leng);            bw.newLine();////因为readLine（）方法不能自动读取换行符，            bw.flush();        }        bw.close();        br.close();    }}

(2)字节高效流
BufferedInputStream—输入流

    构造方法----public BufferedInputStream(InputStream in)

BufferedOutputStream—输出流

构造方法----public BufferedOutputStream(OutputStream out)

用法和基础流的用方法一样

4
转换流
InputStreamReader—是字节流通向字符流的桥梁

     构造方法----  public InputStreamReader(InputStream in)     注意一个问题：     System.in//返回的是一个InputStream的对象     所以     inputStream is=System.is;//这里是多态

//用System.in录入数据，写到文本文件。public static void main(String[] args) throws IOException    {        //从键盘录入数据//      InputStream in=System .in;//      //把字节流转换成字符流//      InputStreamReader isr=new InputStreamReader(in);//      //把字符流转换成高效字符流//      BufferedReader br=new BufferedReader(isr);        //上边的三句话，可以缩减为一条语句        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));        //创建输出流对象，        BufferedWriter bw=new BufferedWriter(new FileWriter("e.txt"));        String len=null;        while((len=br.readLine())!=null)        {            if(len.equals("over"))            {                break;            }            bw.write(len);            bw.newLine();            bw.flush();        }    }}

OutputStreamWriter 是字符流通向字节流的桥梁
（理解，就是把字符流的文件数据输出到字节流的地方并显示 出来）

  构造方法----public OutputStreamWriter(OutputStream out)  小问题：  System.out--返回的是PrintStream（类）对象，  PrintStream（类）继承 FilterOutputStream（类）  FilterOutputStream（类）继承OutputStream（抽象类）  所以，System.out--返回的是OutputStream（抽象类）的子类对象  OutputStream os=System.out；

public class Io6{    public static void main(String[] args) throws IOException, Exception    {        //封装数据源        BufferedReader ps=new BufferedReader(new FileReader("e.txt"));        //封装目的地//      OutputStream os=System.out;//      OutputStreamWriter osa=new OutputStreamWriter(os);//      BufferedWriter bw=new BufferedWriter(osa);        //上边三句 可以压缩为下面的一句        BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));        String lenString=null;        while((lenString=ps.readLine())!=null)        {            bw.write(lenString);            bw.newLine();            bw.flush();        }        bw.close();        ps.close();    }}

5
字符流继承体系简图

字节流继承体系简图

———–android培训、java培训、java学习型技术博客、期待与您交流！————