[2017.11.25]IO流

1.文件的字节输入流
使用改流读数据
public FileInputStream(String name)

2.开发步骤:
1):创建字节文件输入流对象
2)读数据
3)释放资源

3.读数据的两种方式:
1)public int read():一次读取一个字节
2)public int read(byte[] b):一次读取一个字节数组

4.演示:

import java.io.FileInputStream;
import java.io.IOException;

public class FileInputStreamDemo {

    public static void main(String[] args) throws IOException {

        //1)创建文件输入流对象
//      FileInputStream fis = new FileInputStream("fis.txt") ;
        FileInputStream fis = new FileInputStream("FileInputStreamDemo2.java") ;

        //2)读数据
        //public int read():一次读取一个字节
        //第一次读:
        /*int by = fis.read() ;
        System.out.println(by);
        System.out.println((char)by);

        //第二次读取
        by = fis.read() ;
        System.out.println(by);
        System.out.println((char)by);

        //第三次读取
        by = fis.read() ;
        System.out.println(by);
        System.out.println((char)by);

        //第四次读取
        by = fis.read() ;
        System.out.println(by);
        System.out.println((char)by);

        //第五次读取
        by = fis.read() ;
        System.out.println(by);
        System.out.println((char)by);

        //第六次读取
        by = fis.read() ;
        System.out.println(by);
        System.out.println((char)by);*/


        //第七次读取
//      by = fis.read() ;
//      System.out.println(by);
//      System.out.println((char)by);

        /**
         * 上面代码重复非常高,采用循环,由于文件如果内容很多,不知道循环的次数,所以采用
         * while循环,该循环应该有一个结束条件?
         * 通过观察,当该文件读取完毕了 ,返回-1就是结束条件
         */

        //优化改进
    /*  int by = fis.read() ;
        while(by!=-1){
            System.out.println((char)by);
            //继续读
            by = fis.read() ;
        }*/

        //最终版代码:
        //读取,赋值,判断
        //一次读取一个字节的模板代码
        int by = 0 ;
        while((by=fis.read())!=-1){
            //a--->97
            System.out.print((char)by);
        }

        //释放资源
        fis.close() ;

    }
}

import java.util.Arrays;

public class Stringdemo {
    public static void main(String[] args) {

        String s = "我爱你中国" ;

        byte[] bys = s.getBytes() ;
        System.out.println(Arrays.toString(bys));

        //[-50, -46, -80, -82, -60, -29, -42, -48, -71, -6]
    }
}

5.public int read(byte[] b):一次读取一个字节数组
返回的是实际读取的字节数
使用文件输入流一次读取一个字节数组

6.演示:

import java.io.FileInputStream;
import java.io.IOException;

public class FileInputStreamDemo2 {

    public static void main(String[] args) throws IOException {

        //1)创建文件字节输入流对象
        FileInputStream fis = new FileInputStream("fis2.txt") ;
//      FileInputStream fis = new FileInputStream("FileInputStreamDemo.java") ;

        //2)读数据
        //public int read(byte[] b):一次读取一个字节数组
        //定义一个字节数组
/*      byte[] bys = new byte[5] ;//1)10KB

        //指定的字节数组的长度是1024或者是1024的倍数

        //第一次读取
        int len = fis.read(bys) ;
        System.out.println(new String(bys,0,len));

//      //第二次读取
        len = fis.read(bys) ;
        System.out.println(len);
//      System.out.println(new String(bys));
//      
//      //第三次读取
        len = fis.read(bys) ;
//      System.out.println(new String(bys));
//      
//      //第四次读取
        len = fis.read(bys) ;
//      System.out.println(new String(bys));
//      
        len = fis.read(bys) ;
//      System.out.println(new String(bys));
        System.out.println(len);*/


        /**
         * 上述代码重复度高,使用while循环来进行优化改进
         */

        //如果使用模板带去去读取数据:一次读取一个字节数组

        //定义缓冲区大小:指定长度为1024
        byte[] bys = new byte[1024] ;
        int len = 0 ; //读取字节数的实际长度
        while((len=fis.read(bys))!=-1){
//          System.out.println(new String(bys));//hello,world,java 
            //从指定的索引开始(指定0),读取的是实际长度
            System.out.println(new String(bys,0,len));//推荐使用这种格式读取数据:从0开始,读取实际长度
        }

    }
}

7.演示:

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * 需求:在当前项目下有一个:a.txt文件
 *      将a.txt文件的内容赋值到b.txt文件中
 * 
 * 分析:
 * 1)数据源:a.txt------->FileInputStream:输入流------->读数据
 * 2)目的地:b.txt------->FileOutputStream:输出流------>写数据
 */
public class CopyFileDemo {

    public static void main(String[] args) throws IOException {

        //封装数据源:
        //创建一个文件字节输入流对象
        FileInputStream fis = new FileInputStream("a.txt") ;
        //封装目的地
        //创建文件输出流对象
        FileOutputStream fos = new FileOutputStream("b.txt") ;

        //一次读取一个字节:模板代码
        int by = 0 ;
        while((by=fis.read())!=-1){
            //一次读一个字节,使用输出流给b.txt文件写一个字节
            fos.write(by) ;
        }

        //释放资源
        fos.close() ;
        fis.close() ;
    }
}

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * 需求:c盘下有一个a.txt文件内容,复制到d盘下的b.txt文件中,使用字节流读写操作
 * 
 * 分析:数据源:C:\\a.txt文件---->FileInputStream----->读数据
 *     目的地:d:\\b.txt文件------>FileOutputStream---->写数据
 */
public class CopyFileDemo2 {

    public static void main(String[] args) throws IOException {
        //封装数据源
        FileInputStream fis = new FileInputStream("c:\\a.txt") ;
        //封装目的地
        FileOutputStream fos = new FileOutputStream("d:\\b.txt") ;


        //一次读取一个字节
        int by = 0 ;
        while((by=fis.read()) !=-1){
            //写数据
            fos.write(by) ;
        }

        //释放资源:谁先后谁后无所谓
        fis.close() ;
        fos.close() ;
    }
}

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * E盘下有一个高圆圆.jpg文件,将它图片内容复制到当前项目下的mm.jpg
 * 
 * 分析:数据源:----->e:\\高圆圆.jpg----->FileInputStream
 *     目的地-------->mm.jpg------->FileOutputStream 
 */
public class CopyImageDemo3 {

    public static void main(String[] args) throws IOException {

        //封装数据源
        FileInputStream fis = new FileInputStream("e:\\高圆圆.jpg") ;

        //封装目的地
        FileOutputStream fos = new FileOutputStream("mm.jpg") ;

        //读写操作
        int by = 0 ;
        while((by= fis.read())!=-1){
            //写数据
            fos.write(by) ;
        }

        //释放资源
        fis.close() ;
        fos.close() ;
    }
}

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

//使用字节输入流一次读取一个字节复制视频文件---->E:\\abc.mp4--->复制到当前项目:Copy.mp4
public class CopyMp4Demo {

    public static void main(String[] args) throws IOException {

        //封装数据源
        FileInputStream fis = new FileInputStream("E:\\abc.mp4") ;

        //封装目的地
        FileOutputStream fos = new FileOutputStream("Copy.mp4") ;

        //一次读取一个字节
        int by =  0; 
        while((by=fis.read())!=-1){
            fos.write(by) ;
        }

        //释放资源
        fis.close() ;
        fos.close() ;
    }
}

package org.westos_04;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

//使用字节输入流一次读取一个字节复制视频文件---->E:\\abc.mp4--->复制到当前项目:Copy.mp4

//一次读取一个字节数组的速率比一次读取一个字节快!
public class CopyMP4Demo {

    public static void main(String[] args) throws IOException {

        //封装数据源和目的地
        FileInputStream fis = new FileInputStream("e:\\abc.mp4") ;
        FileOutputStream fos = new FileOutputStream("Copy.mp4") ;

        //一次读取一个字节数组
        byte[] bys = new byte[1024] ;
        int len = 0 ;
        while((len=fis.read(bys))!=-1){
            fos.write(bys, 0, len) ;
        }

        //释放资源
        fis.close() ;
        fos.close() ;
    }
}

8.字节缓冲输入流:BufferedInputStream
构造方法:
BufferedInputStream(InputStream in) :指定默认缓冲区大小创建字节缓冲输入流对象

缓冲输入流:一次读取一个字节:
一次读取一个字节数组
两种方式的读取任选一种

9.演示:

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;

public class BufferedInputStreamDemo {

    public static void main(String[] args) throws IOException {

        //创建一个字节缓冲输入流对象
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("bis.txt")) ;

        //一次读取一个字节数组或者一次读取一个字节都可以
        byte[] bys = new byte[1024] ;
        int len = 0 ;
        while((len=bis.read(bys))!=-1){
            System.out.println(new String(bys,0,len));
        }

        //释放资源
        bis.close() ;
    }
}

10.由于字节数组比一次读取一个字节更快,从而引出类更高效的一种流:字节缓冲流
字节缓冲输入流:BufferedInputStream
字节缓冲输出流:BufferedOutputStream

构造方式:
public BufferedOutputStream(OutputStream out):默认缓冲区大小(默认缓冲大小已经足够大了)

11.为什么字节缓冲流不能直接针对文件进行操作呢?
缓冲流只是提供一个缓冲区,针对IO进行实现数据的传输实际是通过底层基本流进行实现的,所以缓冲流不能直接对文件操作

12.flush()和close()方法的区别?
flush():刷新缓冲区的流,强迫将缓冲字节都写到该流中,刷新之后是可以写数据的.
close():关闭流对象所指向指向的这个资源文件,一旦关闭,写数据,写不进去的

13.演示:

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class BufferedOutputStreamDemo {

    public static void main(String[] args) throws IOException {

        //创建字节缓冲输出流对象
        BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream("bos.txt"));//Java的一种设计模式:装饰者设计模式:Scanner sc = new Scanner(System.in) ;

        //写数据
        bos.write(97) ;
        //刷新该缓冲区的流
        bos.flush() ;//迫使将这写字节强制输出流中
        bos.write(98) ;


        //释放资源
        bos.close() ;
        bos.flush() ;
//      bos.write(99) ;
    }
}

14.计算机是如何识别中文的?
1)每个中文左边对应的字节一定是负数
2)GBK格式:右边的字节可以中正数,可以是0,可以是负数

15.演示:

import java.util.Arrays;

public class StringDemo {

    public static void main(String[] args) {

        //定义一个字符串
//      String s = "abcde" ;
        //[97, 98, 99, 100, 101]

        String s = "我爱你中国" ;
        //当前平台默认的编码集:GBK:一个中文对应两个字节
        //[-50, -46, -80, -82, -60, -29, -42, -48, -71, -6]

        //将当前字符串转换成字节数组
        byte[] bys = s.getBytes() ;
//      System.out.println(bys);
        System.out.println(Arrays.toString(bys));
    }
}

16.对于图片文件,音频文件,视频文件,优先采用字节缓冲输入流(高效流)一次读取一个字节数组!
字节流复制文件:
基本字节流(FileInputStream)一次读取一个字节:共耗时:253820毫秒
基本字节流一次读取一个字节数组:共耗时:396毫秒
高效字节流(字节缓冲输入流)一次读取一个字节:共耗时:98020毫秒
高效字节流(字节缓冲输入流)一次读取一个字节数组:共耗时:317毫秒

17.演示:
复制e:\abc.mp4文件—->当前项目下的Copy.mp4文件

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class CopyFileDemo {

    public static void main(String[] args) throws IOException {
        long startTime = System.currentTimeMillis() ;

//      method1("E:\\abc.mp4","Copy.mp4") ;
//      method2("E:\\abc.mp4","Copy.mp4") ;
//      method3("E:\\abc.mp4","Copy.mp4") ;
        method4("E:\\abc.mp4","Copy.mp4") ;
        long endTime = System.currentTimeMillis() ;

        System.out.println("共耗时:"+(endTime-startTime)+"毫秒");
    }

    //高效字节流一次读取一个字节数组
    private static void method4(String SrcString, String destString) throws IOException{

        //封装数据源和目的地
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(SrcString)) ;
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destString)) ;

        //一次读取一个字节数组
        byte[] bys = new byte[1024] ;
        int len = 0 ;
        while((len=bis.read(bys))!=-1){
            bos.write(bys, 0, len) ;
            bos.flush() ;//刷新缓冲区的流
        }

        //释放资源
        bis.close() ;
        bos.close() ;
    }

    //字节缓冲输入流一次读取一个字节
    private static void method3(String SrcString, String destString) throws IOException {

        //创建字节缓冲输入对象
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(SrcString)) ;
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destString)) ;

        //一次读取一个字节
        int by = 0 ;
        while((by=bis.read())!=-1){
            bos.write(by)  ;
            bos.flush() ;
        }

        //释放资源
        bis.close() ;
        bos.close() ;
    }

    //基本的字节流一次读取一个字节数组
    private static void method2(String SrcString, String destString) throws IOException {
        //封装数据源
        FileInputStream fis = new FileInputStream(SrcString) ;
        //封装目的地
        FileOutputStream fos = new FileOutputStream(destString) ;

        //一次读取一个字节数组
        byte[] bys = new byte[1024] ;
        int len = 0 ;
        while((len=fis.read(bys))!=-1){
            //边读边写
            fos.write(bys, 0, len) ;
        }

        //释放资源
        fis.close() ;
        fos.close() ;

    }

    //基本字节流一次读取一个字节
    private static void method1(String StrString, String destString) throws IOException {

        //封装数据源
        FileInputStream fis = new FileInputStream(StrString) ;
        //封装目的地
        FileOutputStream fos = new FileOutputStream(destString) ;

        //一次读取一个字节
        //并且一次写一个字节
        int by = 0 ;
        while((by=fis.read())!=-1){
            //写数据
            fos.write(by) ;
        }


        //释放资源
        fis.close() ;
        fos.close() ;

    }
}

18.字节流一次读取一个字节,出现了中文乱码:
原因是:给字节进行强制类型转换,代码代码的注释中有中文,并且平台默认编码:GBK格式:一个中文对应的两个字节
使用字符流来进行操作:
字符流就必须指定编码格式

19.演示:

import java.io.FileInputStream;
import java.io.IOException;

public class FileInputStreamDemo {

    public static void main(String[] args) throws IOException {

        //创建字节输入流对象
        FileInputStream fis = new FileInputStream("FileInputStreamDemo2.java") ;

        //一次读取一个字节
        int by = 0 ;
        while((by=fis.read())!=-1){
            System.out.print((char)by);
        }

        //释放资源
        fis.close() ;
    }
}

20.编码:就是能看懂的字符串转换成看不懂的字节数组
public byte[] getBytes(Charset charset):将字符串转换成字节数组,指定编码格式(字符集)
解码:就是将看不懂的字节数组—–>能看懂的:将字节数组—>字符串
public String(byte[] bytes, Charset charset)通过使用指定的 编码格式 解码指定的 byte 数组，构造一个新的 String

举例:谍战片
老地方见…
编码
“老”—–>字节数组—–>二进制数据—->
解码:二进制数据—–>十进制数据—–>字节数组—–>构造方式:字符串

21.演示:

import java.io.IOException;
import java.util.Arrays;

public class StringDemo {

    public static void main(String[] args) throws IOException {

        String s = "爱你" ;

        //编码
//      byte[] bys = s.getBytes("utf-8")    ;//:GBK[-80, -82, -60, -29]
                                            //utf-8:[-25, -120, -79, -28, -67, -96]

        //如果不写编码格式:默认GBK
        byte[] bys = s.getBytes() ;//[-80, -82, -60, -29]
//      System.out.println(bys);
        System.out.println(Arrays.toString(bys));

        //解码
        //public String(byte[] bytes, Charset charset)
//      String str = new String(bys, "GBK") ;
        String str = new String(bys) ;//默认GBK
        System.out.println(str);//爱你
    }
}

22.字符输入流:字节输入流+编码格式(默认GBK)
public InputStreamReader(InputStream in,charset sc) ;

23.演示:

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

public class InputStreamReaderDemo {

    public static void main(String[] args) throws IOException {

        //创建字符输入流对象
        /*InputStreamReader isr = new InputStreamReader(new FileInputStream(
                "osw.txt"), "GBK");*/
        InputStreamReader isr = new InputStreamReader(new FileInputStream(
                "osw.txt"));//以GBK格式读数据

        //读数据:一次读取一个字符
        /*int ch = 0 ;
        while((ch=isr.read())!=-1){
            System.out.print((char)ch);
        }*/

        char[] chs = new char[1024] ;
        int len = 0;
        while((len=isr.read(chs))!=-1){
            System.out.println(new String(chs, 0, len));
        }

        //释放资源
        isr.close() ;
    }
}

24.字符输出流:
Writer:是一个抽象类
使用的是该抽象类的子类:OutputStreamWriter——>字符转换流:可以将字节输出流转换字符流
public OutputStreamWriter(OutputStream out,Charset cs):创建一字符输出转换流对象,指定编码格式
字节输出流+编码格式—->字符输出流

编码格式:使用平台的默认编辑集进行编码:GBK
public OutputStreamWriter(OutputStream out) ;

25.演示:

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.Writer;

public class OutputStreamWriterDemo {

    public static void main(String[] args) throws IOException {

        //创建一个字符输出流对象
        //public OutputStreamWriter(OutputStream out,Charset cs)
//      Writer w = new OutputStreamWriter(new FileOutputStream("w.txt"), "GBK") ;//抽象类多态
//      OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
//              "osw.txt"), "GBK");

        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
                "osw.txt"));//默认GBK


        //写数据
        osw.write("中国") ;

        //释放资源
        osw.close() ;


    }
}

26.使用字符转换流进行操作数据的时候:字节流+编码格式
并且在书写代码名称非常长,Java提供了以中更简单的类:便捷类:
字符转换输入流:InputStreamReader—–>FileReader
FileReder(String fileName)
字符转换输出流:OutputStreamWriter—->FileWriter
FileWriter(String fileName)

27.演示:
需求：把当前项目目录下的a.txt内容复制到当前项目目录下的b.txt中 使用字符流进行读写操作
分析:
数据源:a.txt—->字符流读数据:InputStreamReader——>便捷类:FileReader
目的地:b.txt—->字符流写数据:OutputStreamWriter—–>便捷类:FileWriter

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class FileReaderDemo {

    public static void main(String[] args) throws IOException {


        //1)封装数据源和目的地
        FileReader fr = new FileReader("a.txt") ;
        FileWriter fw = new FileWriter("b.txt") ;

        //一次读取一个字符数组
        char[] chs = new char[1024] ;
        int len = 0 ;
        while((len=fr.read(chs))!=-1){
            fw.write(chs, 0, len) ;
            fw.flush() ;
        }

        //关闭资源
        fw.close() ;
        fr.close() ;
    }
}

28.字符输入流读数据的方式:
public int read():一次读取一个字符
public int read(char[] chs):一次读取一个字符数组

29.演示:

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

public class InputStreamReaderDemo {

    public static void main(String[] args) throws IOException {

        //1)创建字符输入流对象
        InputStreamReader isr = new InputStreamReader(new FileInputStream(
                "FileInputStreamDemo2.java"));

        //2)方式1:一次读取一个字符
        /*int ch = 0 ;
        while((ch=isr.read())!=-1){
            System.out.print((char)ch);
        }*/

        //2)方式2:一次读取一个字符数组
        char[] chs = new char[1024] ;
        int len = 0 ;
        while((len=isr.read(chs))!=-1){
            System.out.println(new String(chs, 0, len));
        }


        //释放资源
        isr.close() ;
    }

}

30.关于字符输出流写数据的方法:
public void write(int c):写单个字符
public void write(char[] cbuf):写一个字符数组
public abstract void write(char[] cbuf,int off,int len):写入字符数组的一部分
public void write(String str):写字符串
public void write(String str, int off,int len):写字符串的一部分

31.演示:

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;

public class OutputStreamDemo {

    public static void main(String[] args) throws IOException {

        //创建字符输出流对象
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
                "osw2.txt"));

        //写数据
        //public void write(int c):写单个字符
//      osw.write(97) ;
//      osw.write('a') ;

        //public void write(char[] cbuf):写一个字符数组
        //定义一个字符数组:静态初始化
//      char[] chs = {'a','b','c','d','e'}   ;
////        osw.write(chs) ;
//      
//      //public abstract void write(char[] cbuf,int off,int len):写入字符数组的一部分
//      osw.write(chs, 1, 3) ;

        //public void write(String str):写字符串
        String str = "我爱高圆圆" ;
        osw.write(str) ;

        //public void write(String str, int off,int len):写字符串的一部分
        osw.write(str, 1, 3) ;


        //void flush()刷新该流
        osw.flush() ;


        //关闭流对象
        osw.close() ;
//      osw.write('b') ;//字符输出流:如果流已经关闭,那么写数据会报异常!
    }
}

32.演示:
需求：把当前项目目录下的a.txt内容复制到当前项目目录下的b.txt中 使用字符流进行读写操作
分析
数据源:a.txt—->Reader—->InputStreamReader(InputStream in):字符转换输入流
目的地:b.txt—->Writer—->OutputStreamWriter(Outputstream out):字符转换输出流

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

public class CopyFileTest {

    public static void main(String[] args) throws IOException {

        //1)创建字符转换输入流对象
        InputStreamReader isr = new InputStreamReader(new FileInputStream(
                "a.txt"));

        //2)封装目的地
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
                "b.txt"));

        //一次读取一个字符数组
        char[] chs = new char[1024] ;
        int len = 0;
        while((len=isr.read(chs))!=-1){
            //写数据:
            osw.write(chs, 0, len) ;
            //刷新流
            osw.flush() ;
        }

        //释放资源
        isr.close() ;
        osw.close() ;
    }
}

33.关于字符缓冲输入流的特有功能:
BufferedWriter:
public void newLine():写入一个换行符号
BufferReader:
public String readLine():一次读取一行

34.演示:

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class BufferedDemo {

    public static void main(String[] args) throws IOException {

        write();

        read();
    }

    private static void read() throws FileNotFoundException, IOException {
        //读数据
        //创建一个字符缓冲输入流对象
        BufferedReader br = new BufferedReader(new FileReader("bw2.txt")) ;

        //读数据
        //public String readLine():一次读取一行
        /*String line = br.readLine() ;
        System.out.println(line);

        //第二次读取
        line = br.readLine() ;
        System.out.println(line);

        line = br.readLine() ;
        System.out.println(line);

        //第二次读取
        line = br.readLine() ;
        System.out.println(line);
     line = br.readLine() ;
        System.out.println(line);

        //第二次读取
        line = br.readLine() ;
        System.out.println(line);
         line = br.readLine() ;
        System.out.println(line);

        //第二次读取
        line = br.readLine() ;
        System.out.println(line);
         line = br.readLine() ;
        System.out.println(line);

        //第二次读取
        line = br.readLine() ;
        System.out.println(line);

         line = br.readLine() ;
        System.out.println(line);

        //第二次读取
        line = br.readLine() ;
        System.out.println(line);
         line = br.readLine() ;
        System.out.println(line);

        //第二次读取
        line = br.readLine() ;
        System.out.println(line);*/

        //这种方式读数据:一次读取一行数据,什么时候结束?
        //当数据读取完毕,如果返回值是null,说明已经读完了

        //代码重复度高,使用循环改进
        String line = null ;
        while((line=br.readLine())!=null){
            System.out.println(line);
        }
        //释放资源
        br.close() ;
    }

    private static void write() throws IOException {
        //写数据
        //创建一个字符缓冲输出流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("bw2.txt")) ;

        //写数据
        for(int x = 0 ; x <10 ; x ++){
            bw.write("hello"+x) ;
            //没有使用这个方法之前:使用写入换行符号
//          bw.write("\r\n") ;
            //使用特有功能
            bw.newLine() ;

            //刷新该流
            bw.flush() ;
        }

        //释放资源
        bw.close() ;
    }
}

35.字符缓冲输入流
BufferedReader
BufferedReader(Reader in) :创建默认缓冲大小

36.演示:

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class BufferedReaderDemo {

    public static void main(String[] args) throws IOException {

        //1)创建字符缓冲输入流对象
        BufferedReader br = new BufferedReader(new FileReader("bw.txt")) ;

        //方式1:一次读取一个字符
//      int ch = 0 ;
//      while((ch=br.read())!=-1){
//          System.out.print((char)ch);
//      }

        //方式2:一次读取一个字符数组
        char[] chs = new char[1024] ;
        int len = 0 ;
        while((len = br.read(chs))!=-1){
            System.out.println(new String(chs, 0, len));
        }

//      关闭资源
        br.close() ;
    }
}

37.字符流为了提高读写速度,Java就提供了一个字符缓冲流的类:
BufferedReader:字符缓冲输入流
BufferedWriter:字符缓冲输出流
将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。
可以指定缓冲区的大小，或者接受默认的大小

构造方式:
public BufferedWriter(Writer out):创建默认缓冲区大小的一个字符缓冲输出流

38.演示:

import java.io.BufferedWriter;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;

public class BufferedWriterDemo {

    public static void main(String[] args) throws IOException {

        //创建字符缓冲输出流对象
        //public BufferedWriter(Writer out)
        /*BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(
                new FileOutputStream("bw.txt")));*/
        BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt")) ;

        //写数据
        bw.write("javaee") ;
        bw.write("hello") ;
        bw.write("world") ;
        bw.write("java") ;




        //刷新流
        bw.flush() ;

        //关闭资源
        bw.close() ;
    }

39.演示:

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.util.Scanner;

public class Demo {

    public static void main(String[] args) throws IOException {

        //1)创建键盘录入对象
        /*Scanner sc = new Scanner(System.in);//InputStream is = System.in;

        System.out.println("请您输入一个字符串:");
        String line = sc.nextLine() ;
        System.out.println(line);*/

        //使用IO流的形式读数据
        //BufferedReadr进行包装
    /*  InputStream is = System.in ;//标准输入流
     * 
     *  

        //使用is对象能不能一次读取一个数据呢?
        //不能使用它进行读取数据,BufferedReader可以

        //BufferedReader br = new BufferedReader(is) ;//字符缓冲输入流只能针对字符输入流进行操作,不能针对字节流进行操作

        //需要将标准输入流转换成字符输入流:InputStreamReader(InputStream in)
        //创建字符转换输入流对象
        InputStreamReader isr = new InputStreamReader(is) ;

        //创建字符缓冲输入流对象
        BufferedReader br = new BufferedReader(isr) ;*/
        //一步走
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in)) ;

        System.out.println("请输入一个整数:");
        String str = br.readLine() ;//返回值是一个字符串

        int number = Integer.parseInt(str) ;
        System.out.println("您输入的整数是:"+number);

        //标准输出流
//      PrintStream out = System.out ;
        //PrintWriter

    }
}