黑马程序员——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学习型技术博客、期待与您交流！————