毕向东Java视频学习笔记【day21-IO流<1>】

01-IO流(输入流&输出流)

输入流和输出流相对于内存设备而言.

将外设中的数据读取到内存中:输入
将内存的数写入到外设中：输出。

---

02-IO流(字节流&字符流)

字符流的由来：

其实就是：字节流读取文字字节数据后，不直接操作而是先查指定的编码表。获取对应的文字。
在对这个文字进行操作。简单说：字节流+编码表

字节流的两个顶层父类：
1，InputStream 2，OutputStream.

字符流的两个顶层父类：
1，Reader 2，Writer

这些体系的子类都以父类名作为后缀。
而且子类名的前缀就是该对象的功能。

---

03-IO流(字符流-FileWriter)

    package cn.itcast.p2.io.filewriter;    import java.io.FileWriter;    import java.io.IOException;    //需求：将一些文字存储到硬盘一个文件中。       public class FileWriterDemo {    private static final String LINE_SEPARATOR = System.getProperty("line.separator");    public static void main(String[] args) throws IOException {        //创建一个可以往文件中写入字符数据的字符输出流对象。        /*         * 既然是往一个文件中写入文字数据，那么在创建对象时，就必须明确该文件(用于存储数据的目的地)。         *          * 如果文件不存在，则会自动创建。         * 如果文件存在，则会被覆盖。         *          * 如果构造函数中加入true，可以实现对文件进行续写！         */         FileWriter fw = new FileWriter("demo.txt",true);         /*         * 调用Writer对象中的write(string)方法，写入数据。          *          * 其实数据写入到临时存储缓冲区中。         *          */         fw.write("abcde"+LINE_SEPARATOR+"hahaha");         /*         * 进行刷新，将数据直接写到目的地中。         */         fw.flush();         /*         * 关闭流，关闭资源。在关闭前会先调用flush刷新缓冲中的数据到目的地。         */        fw.close();    }}

• FileWriter.write();

  • 写入流中（内存中），但是没保存到硬盘上

• FileWriter.flush();

  • 刷新，保存到硬盘上
  • 相当于写文档时的ctrl+s

• FileWriter.close();

  • 关闭流
  • 会自动调用flush，再关闭。
  • 在关闭后，无法在使用flush和write。
  • 相当于关闭一个txt文件，就无法再保存和写入了。

-

04-IO流(字符流-FileWriter-细节(换行和续写))

换行

• fw.write(“abcde”+LINE_SEPARATOR+”hahaha”);
• fw.write(“abcde\r\nhahaha”);//windows中换行是\r\n

续写，只用在new对象时，增加一个true参数，默认是false

FileReader fr = new FileReader("d:\\demo.txt"，true);

---

05-IO流(字符流-FileWriter-IO异常处理)

• if (fw != null) 一定要记住这一步

package day20;import java.io.FileWriter;import java.io.IOException;public class IOExceptionDemo {    private static final String LINE_SEPARATOR = System            .getProperty("line.separator");    /**     * @param args     * @throws IOException     */    public static void main(String[] args) {        FileWriter fw = null;        try {            fw = new FileWriter("d:\\demo.txt");            fw.write("abcde" + LINE_SEPARATOR + "hahaha");        } catch (Exception e) {            System.out.println(e.toString());        } finally {            if (fw != null) {//一定要记住这一步                try {                    fw.close();                } catch (IOException e) {                    // TODO 自动生成的 catch 块                    e.printStackTrace();                    throw new RuntimeException("关闭失败");                }            }        }    }}

---

06-IO流(字符流-FileReader-读取方式一)

• FileReader.read()

  • 第一次调用只读取第1个字符的二进制
  • 第二次调用就读取下一个字符
  • 如果读到文件结尾，返回-1

• 一般这样写来读取文件中的内容

            while((ch=fr.read())!=-1){            System.out.println((char)ch);            }

---

07-IO流(字符流-FileReader-读取方式二)

• System.out.println(new String(buf,0,len));
  
  • 输出buf字符数组中从0到len-1的字符

一般buf字符数组的长度为1024的倍数

char[] buf = new char[3];

• FileReader.read(buf)读取3个字符到buf字符数组中。
  
  • int num = read(buf)
    
    • 能返回读取字符的长度，如果只有2个字符，buf数组长度为3，返回长度2赋给num.
    • 如果1个都读取不到，返回0，并且buf为空
      

• 一般这样写

  while((len=fr.read(buf))!=-1){        System.out.println(new String(buf,0,len));}

---

08-IO流(字符流–复制文本文件_1)

package day21;import java.io.FileReader;import java.io.FileWriter;import java.io.IOException;/* * 需求：将c盘的一个文本文件复制到d盘。 *  * 思路： * 1，需要读取源， * 2，将读到的源数据写入到目的地。 * 3，既然是操作文本数据，使用字符流。  *  */public class CopyTextTest {    /**     * @param args     * @throws IOException      */    public static void main(String[] args) throws IOException {        //1,读取一个已有的文本文件，使用字符读取流和文件相关联。        FileReader fr = new FileReader("d:\\Demo.txt");        //2,创建一个目的，用于存储读到数据。        FileWriter fw = new FileWriter("d:\\copytext_1.txt");        //3,频繁的读写操作。        int ch = 0;        while((ch=fr.read())!=-1){            fw.write(ch);        }        //4,关闭流资源。         fw.close();        fr.close();    }}

---

09-IO流(字符流–复制文本文件_2)

package day21;import java.io.FileReader;import java.io.FileWriter;import java.io.IOException;public class CopyTextTest_2 {    private static final int BUFFER_SIZE = 1024;    /**     * @param args     */    public static void main(String[] args) {        FileReader fr = null;        FileWriter fw = null;        try {            fr = new FileReader("d:\\Demo.txt");            fw = new FileWriter("d:\\copytest_2.txt");            //创建一个临时容器，用于缓存读取到的字符。            char[] buf = new char[BUFFER_SIZE];//这就是缓冲区。             //定义一个变量记录读取到的字符数，(其实就是往数组里装的字符个数 )            int len = 0;            while((len=fr.read(buf))!=-1){                fw.write(buf, 0, len);            }        } catch (Exception e) {            throw new RuntimeException("读写失败");        }finally{            if(fw!=null)                try {                    fw.close();                } catch (IOException e) {                    e.printStackTrace();                }            if(fr!=null)                try {                    fr.close();                } catch (IOException e) {                    e.printStackTrace();                }        }    }}

---

10-IO流(字符流-练习-复制文本文件_图解)

波浪线–流
两个流之间没有必然的联系
是通过一个媒介将其联系在一起

这个媒介其实就是缓冲区

11-IO流(字符流-缓冲区-解释)

设计优化-重构

加入设计模式，提升灵活性、复用性

性能优化

缓冲区的使用，高效性能

---

12-IO流(字符流-缓冲区-BufferedWriter)

缓冲区是提高效率神器

• BufferWriter其实封装了数组 用数组来缓冲
  
  • FileWriter fw = new FileWriter(“buf.txt”);
  • new对象时，必须有缓冲的对象“buf.txt”

import java.io.*;public class BufferedWriterDemo {    @SuppressWarnings("unused")    private static final String LINE_SEPARATOR = System.getProperty("line.separator");    public static void main(String[] args) throws IOException {        FileWriter fw = new FileWriter("buf.txt");        //为了提高写入的效率。使用了字符流的缓冲区。        //创建了一个字符写入流的缓冲区对象，并和指定要被缓冲的流对象相关联        BufferedWriter bufw = new BufferedWriter(fw);        //使用缓冲区的写入方法将数据先写入到缓冲区中。        bufw.write("asdasd");        //关闭缓冲区。其实关闭的就是被缓冲的流对象。        bufw.close();    }}

关闭缓冲区的流对象，流对象不存在了，就不用再关闭fw的流对象（fw.close）。

• buwf.newLine();
  
  • 换行
  • 注意：但是只有BufferWriter中有。

养成习惯刷新flush保存的习惯（ctrl+s）

        for(int x=1; x<=4; x++){            bufw.write("abcdef"+x);            bufw.newLine();            bufw.flush();        }

---

13-IO流(字符流-缓冲区-BufferedReader)

• BufferedReader.readLine:string
  
  • 读取文件中的行 行以回车为准（\r\n）
  • 如果行中无内容，String返回null

    while((line=bufr.readLine())!=null){        System.out.println(line);    }

---

14-IO流(字符流-缓冲区-BufferedReader-readLine方法原理)

BufferedReader：StringBuilder

readLine()使用了读取缓冲区的read方法，（不读取\n换行、\r回车）将读取到的字符进行缓冲并且进行判断换行标记，将标记前的缓存数据变成字符串返回。

---

15-IO流(字符流-缓冲区-复制文本文件)

用bufferReader和bufferWriter复制文本文件

import java.io.*;public class CopyTextByBufTest {    public static void main(String[] args) throws IOException {        FileReader fr = new FileReader("buf.txt");              BufferedReader bufr = new BufferedReader(fr);        FileWriter fw = new FileWriter("buf_copy.txt");        BufferedWriter bufw = new BufferedWriter(fw);        String line = null;        //读取一行换行        while((line=bufr.readLine())!=null){            bufw.write(line);            bufw.newLine();            bufw.flush();        }        /*        int ch = 0;        while((ch=bufr.read())!=-1){            bufw.write(ch);        }        */        bufw.close();        bufr.close();    }}

---

16、17-IO流(字符流-缓冲区-自定义MyBufferedReader-read和readLine方法)

自定义的读取缓冲区。其实就是模拟一个BufferedReader.

分析：
缓冲区中无非就是封装了一个数组，
并对外提供了更多的方法对数组进行访问。
其实这些方法最终操作的都是数组的角标。

缓冲的原理：
其实就是从源中获取一批数据装进缓冲区中。
在从缓冲区中不断的取出一个一个数据。

在此次取完后，在从源中继续取一批数据进缓冲区。
当源中的数据取光时，用-1作为结束标记。

package day21.cn.itcast.p4.io.charstream.mybuffer;import java.io.FileReader;import java.io.IOException;import java.io.Reader;public class MyBufferedReader extends Reader {    private Reader r;    //定义一个数组作为缓冲区。    private char[] buf = new char[1024];    //定义一个指针用于操作这个数组中的元素。当操作到最后一个元素后，指针应该归零。        private int pos = 0;        //定义一个计数器用于记录缓冲区中的数据个数。 当该数据减到0，就从源中继续获取数据到缓冲区中。    private int count = 0;    MyBufferedReader(Reader r){        this.r = r;    }    public int myRead() throws IOException{        //1,从源中获取一批数据到缓冲区中。需要先做判断，只有计数器为0时，才需要从源中获取数据。        if(count==0){            count = r.read(buf);            pos = 0;        }        if(count<0)            return -1;        char ch = buf[pos++];        count--;        return ch;    }    public String myReadLine() throws IOException{        StringBuilder sb = new StringBuilder();        int ch = 0;        while((ch = myRead())!=-1){            if(ch=='\r')                continue;            if(ch=='\n')                return sb.toString();            //将从缓冲区中读到的字符，存储到缓存行数据的缓冲区中。            sb.append((char)ch);        }               if(sb.length()!=0)            return sb.toString();        return null;    }    public void myClose() throws IOException {        r.close();    }}

---

18-IO流(字符流-缓冲区-装饰设计模式)

• 装饰设计模式：
  
  • 对一组对象的功能进行增强时，就可以使用该模式进行问题的解决。

public class PersonDemo {    public static void main(String[] args) {        Person p = new Person();        NewPerson p1 = new NewPerson(p);        p1.chifan();        NewPerson2 p2 = new NewPerson2();        p2.chifan();    }}class Person{    void chifan(){        System.out.println("吃饭");    }}//这个类的出现是为了增强Person而出现的。class NewPerson{//装饰模式    private Person p ;    NewPerson(Person p){        this.p = p;    }    public void chifan(){        System.out.println("开胃酒");        p.chifan();        System.out.println("甜点");    }}class NewPerson2 extends Person{//继承    public void chifan(){        System.out.println("开胃酒");        super.chifan();        System.out.println("甜点");    }}

---

19-IO流(字符流-缓冲区-装饰设计模式和继承的区别)

装饰和继承都能实现一样的特点：进行功能的扩展增强。

有什么区别呢？

首先有一个继承体系。
Writer
|–TextWriter:用于操作文本
|–MediaWriter：用于操作媒体。

想要对操作的动作进行效率的提高。
按照面向对象，可以通过继承对具体的进行功能的扩展。
效率提高需要加入缓冲技术。

Writer    |--TextWriter:用于操作文本        |--BufferTextWriter:加入了缓冲技术的操作文本的对象。    |--MediaWriter：用于操作媒体。        |--BufferMediaWriter:

如果这个体系进行功能扩展，又多了流对象。
那么这个流要提高效率，是不是也要产生子类呢？是。这时就会发现只为提高功能，进行的继承，
导致继承体系越来越臃肿。不够灵活。

---

重新思考这个问题？用装饰模式

既然加入的都是同一种技术–缓冲。
前一种是让缓冲和具体的对象相结合。
可不可以将缓冲进行单独的封装，哪个对象需要缓冲就将哪个对象和缓冲关联。

class Buffer{    Buffer(TextWriter w)    {}    Buffer(MediaWirter w)    {}}class BufferWriter extends Writer{    BufferWriter(Writer w)    {}}

装饰也可用继承的表达方式。

    Writer        |--TextWriter:用于操作文本        |--MediaWriter：用于操作媒体。        |--BufferWriter:用于提高效率。

装饰比继承灵活。

特点：装饰类和被装饰类都必须所属同一个接口或者父类。

---

20-IO流(字符流-缓冲区-LineNumberReader)

• LineNumberReader 方法
  
  • 设置行号

---

21-IO流(字节流-操作文件基本演示)

字节流是不需要临时存储缓冲的，是直接写入目的地中，所以不需要flush方法，但是close方法还是需要的（关闭资源动作）。

• “asdasd”.getBytes() 把字符串改成字符

• InputStream.available()文件的大小字节

  • 对小文件可以使用
  • 对大文件最好不去使用
    在真正读数据的时候最好new一个1024的字节数组，循环读取文件

---

22-IO流(字节流-练习-复制MP3)

copy_01：建议的方法

copy_02：建议的方法

copy_03：不建议。 如果文件过大，要不断创建数组，很慢，如果文件过大，直接溢出。

copy_04:千万不要用，效率没有！读一个写一个很慢

package day21.cn.itcast.p7.io.bytestream.test;import java.io.BufferedInputStream;import java.io.BufferedOutputStream;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.IOException;public class CopyMp3Test {    /**     * @param args     * @throws IOException      */    public static void main(String[] args) throws IOException {        copy_4();    }//  千万不要用，效率没有！读一个写一个很慢    public static void copy_4() throws IOException {        FileInputStream fis = new FileInputStream("c:\\0.mp3");             FileOutputStream fos = new FileOutputStream("c:\\4.mp3");        int ch = 0;        while((ch =fis.read())!=-1){            fos.write(ch);        }        fos.close();        fis.close();    }    //不建议。 如果文件过大，要不断创建数组，很慢，如果文件过大，直接溢出    public static void copy_3() throws IOException {        FileInputStream fis = new FileInputStream("c:\\0.mp3");             FileOutputStream fos = new FileOutputStream("c:\\3.mp3");        byte[] buf = new byte[fis.available()];        fis.read(buf);        fos.write(buf);        fos.close();        fis.close();    }    public static void copy_2() throws IOException {        FileInputStream fis = new FileInputStream("c:\\0.mp3");         BufferedInputStream bufis = new BufferedInputStream(fis);        FileOutputStream fos = new FileOutputStream("c:\\2.mp3");        BufferedOutputStream bufos = new BufferedOutputStream(fos);        int ch = 0;        while((ch=bufis.read())!=-1){            bufos.write(ch);        }        bufos.close();        bufis.close();    }    public static void copy_1() throws IOException {        FileInputStream fis = new FileInputStream("c:\\0.mp3");             FileOutputStream fos = new FileOutputStream("c:\\1.mp3");        byte[] buf = new byte[1024];        int len = 0;        while((len=fis.read(buf))!=-1){            fos.write(buf,0,len);        }        fos.close();        fis.close();    }}