2018-08-22字节字符转换流InputStreamReader+OutputStreamWriter+缓冲流Buffered+newLine换行方法

OutputStreamWriter类：

查阅OutputStreamWriter的API介绍，OutputStreamWriter 是字符流通向字节流的桥梁：可使用指定的字符编码表（一般是GBK和UTF-8），将要写入流中的字符编码成字节！它的作用的就是，将字符串按照指定的编码表转成字节，在使用字节流将这些字节写出去！

OutputStreamWriter流对象，它到底如何把字符转成字节输出的呢？

其实在OutputStreamWriter流中维护自己的缓冲区，当我们调用OutputStreamWriter对象的Write方法时，会拿着字符到指定的码表中进行查询，把查到的字符编码值转成字节数存放到OutputStreamWriter缓冲区中！然后再调用刷新功能，或者关闭流，或者缓冲区存满后会把缓冲区中的字节数据使用字节流写到指定的文件中！

InputStreamReader类：

查阅InputStreamReader的API介绍，InputStreamReader 是字节流通向字符流的桥梁：它使用指定的字符编码表读取字节并将其解码为字符！ 它使用的字符集可以由名称指定或显式给定，或者可以接受平台默认的字符集！

//在读取指定的编码的文件时，一定要指定编码格式，否则就会发生解码错误，而发生乱码现象！

FileWriter继承自OutputStreamWriter类！

FileReader继承自InputStreamReader类！

OutputStreamWriter和InputStreamReader是字符和字节的桥梁：也可以称之为字符转换流（字符转换流原理：字节流+编码表）！

FileWriter和FileReader：作为子类，仅作为操作字符文件的便捷类存在！当操作的字符文件，使用的是默认编码表（GBK）时可以不用父类，而直接用子类就完成操作了，简化了代码！

转换流示例代码：

package com.oracle.zhuanhuan;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
public class InputStreamReaderDemo {
    public static void main(String[] args) throws IOException {
        FileInputStream fis=new FileInputStream("F:\IOTest\UTF8.txt");
        InputStreamReader Isr=new InputStreamReader(fis,"UTF-8");
        char[] ch=new char[1024];
        int len=0;
        while((len=Isr.read(ch))!=-1){
            System.out.println(new String(ch,1,len));
        }
        Isr.close();
    }
}
//字节与字符之间的转换，不能转编码，用字节流读取txt文件，然后转换成字符流打印出来！

package com.oracle.zhuanhuan;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
public class OutputStreamWriterDemo {
    public static void main(String[] args) throws IOException {
        //明确目的地：
        FileOutputStream fos=new FileOutputStream("F:\IOTest\UTF8.txt",true);
        //指定UTF-8编码，不指定默认是GBK：
        //Osw中已经装入fos，当关闭Osw时会自动关闭fos！
        OutputStreamWriter Osw=new OutputStreamWriter(fos,"UTF-8");
        Osw.write("沙漠皇帝黄金脆皮鸡");
        Osw.close();
        //Input读，Output写，参照物内存与文件之间！
    }
}

字节缓冲流：

写入数据到流中，字节缓冲输出流BufferedOutputStream！

读取流中的数据，字节缓冲输入流 BufferedInputStream！

不能用记事本打开的就用字节流，可以用记事本打开的用字符流！

字节缓冲流主要作用就是加速！

课堂代码：

package com.oracle.buffered;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.FileInputStream;
import java.io.IOException;
public class Demo01 {
    public static void main(String[] args) throws IOException {
        method2();
    }
    //缓冲字节输出流：
    public static void method1() throws IOException{
        FileOutputStream fos=new FileOutputStream("F:\IOTest\TestReader.txt",true);
        //Buffered加速作用：
        BufferedOutputStream bos=new BufferedOutputStream(fos);
        bos.write("FUCKYOU".getBytes());
        bos.close();
    }
    //缓冲字节输入流：
    public static void method2() throws IOException{
        FileInputStream fos=new FileInputStream("F:\IOTest\TestReader.txt");
        //Buffered加速作用：
        BufferedInputStream bis=new BufferedInputStream(fos);
        int len=0;
        while((len=bis.read())!=-1){
            System.out.println((char)len);
        }
        bis.close();
    }
}

上午作业：

package com.oracle.homework;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class HW1 {
    public static void main(String[] args) throws IOException {
        //字节流read()方法复制文件需要多久：
        //获取程序开始时的毫秒数：
        long startTime=System.currentTimeMillis();
        //找到数据源：
        FileInputStream fis=new FileInputStream("F:\IOTest\mysql-connector-java-5.1.37.zip");
        //明确目的地：
        FileOutputStream fos=new FileOutputStream("F:\IOTest\TestCopy\mysql-connector-java-5.1.37.zip");
        int len=0;
        while((len=fis.read())!=-1){
            fos.write(len);
        }
        fis.close();
        fos.close();
        //获取程序结束时的毫秒数：
        long endTime=System.currentTimeMillis();
        //转换成分秒格式：
        double getRunTime=(endTime-startTime);
        System.out.println("复制该文件用时："+getRunTime+"毫秒！");
    }
}

package com.oracle.homework;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class HW2 {
    public static void main(String[] args) throws IOException {
        //字节流read(byte[])方法复制文件需要多久：
        //获取程序开始时的毫秒数：
        long startTime=System.currentTimeMillis();
        //找到数据源：
        FileInputStream fis=new FileInputStream("F:\IOTest\mysql-connector-java-5.1.37.zip");
        //明确目的地：
        FileOutputStream fos=new FileOutputStream("F:\IOTest\TestCopy\mysql-connector-java-5.1.37.zip");
        byte[] bytes=new byte[1024];
        while((fis.read(bytes))!=-1){
            fos.write(bytes);
        }
        fis.close();
        fos.close();
        //获取程序结束时的毫秒数：
        long endTime=System.currentTimeMillis();
        //转换成分秒格式：
        double getRunTime=(endTime-startTime);
        System.out.println("复制该文件用时："+getRunTime+"毫秒！");
    }
}

package com.oracle.homework;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class HW3 {
    public static void main(String[] args) throws IOException {
        //缓冲字节流read()方法复制文件需要多久:
        //获取程序开始时的毫秒数：
        long startTime=System.currentTimeMillis();
        //获取数据源：
        FileInputStream fis=new FileInputStream("F:\IOTest\mysql-connector-java-5.1.37.zip");
        //用字节缓冲流加速一下：
        BufferedInputStream bis=new BufferedInputStream(fis);
        //明确目的地：
        FileOutputStream fos=new FileOutputStream("F:\IOTest\TestCopy\mysql-connector-java-5.1.37.zip");
        //用字节缓冲流加速一下：
        BufferedOutputStream bos=new BufferedOutputStream(fos);
        //对两个字节缓冲流进行不可描述的操作：
        int len=0;
        while((len=bis.read())!=-1){
            bos.write(len);
        }
        //关闭流
        bis.close();
        bos.close();
        //获取程序结束时的毫秒数：
        long endTime=System.currentTimeMillis();
        //转换成分秒格式：
        double getRunTime=(endTime-startTime);
        System.out.println("复制该文件用时："+getRunTime+"毫秒！");
    }
}

package com.oracle.homework;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class HW4 {
    public static void main(String[] args) throws IOException {
        //缓冲字节流read(byte[])方法复制文件需要多久：
        //获取程序开始时的毫秒数：
        long startTime=System.currentTimeMillis();
        //获取数据源：
        FileInputStream fis=new FileInputStream("F:\IOTest\mysql-connector-java-5.1.37.zip");
        //用字节缓冲流加速一下：
        BufferedInputStream bis=new BufferedInputStream(fis);
        //明确目的地：
        FileOutputStream fos=new FileOutputStream("F:\IOTest\TestCopy\mysql-connector-java-5.1.37.zip");
        //用字节缓冲流加速一下：
        BufferedOutputStream bos=new BufferedOutputStream(fos);
        //对两个字节缓冲流进行不可描述的操作：
        byte[] bytes=new byte[1024];
        while((bis.read(bytes))!=-1){
            bos.write(bytes);
        }
        //关闭流
        bis.close();
        bos.close();
        //获取程序结束时的毫秒数：
        long endTime=System.currentTimeMillis();
        //转换成分秒格式：
        double getRunTime=(endTime-startTime);
        System.out.println("复制该文件用时："+getRunTime+"毫秒！");
    }
}

平台无关性的newLine()方法：

package com.oracle.buffered;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class Demo02 {
    public static void main(String[] args) throws IOException {
        method3();
    }
    //缓冲字符输出流：
    public static void method1() throws IOException{
        FileWriter fw=new FileWriter("F:\IOTest\TestA.txt");
        BufferedWriter bw=new BufferedWriter(fw);
        bw.write("你好么".toCharArray());
        //newLine可以实现平台无关性！
        //Windows下换行是

        //Linux下换行是

        bw.flush();
        bw.newLine();//换行！
        bw.write("FUCKYOU");
        bw.newLine();
        bw.write(100);
        bw.close();
    }
    public static void method2() throws IOException{
        FileReader fr=new FileReader("F:\IOTest\TestA.txt");
        BufferedReader bfr=new BufferedReader(fr);
        String Str=null;
        int i=0;
        while((Str=bfr.readLine())!=null){
            System.out.println((++i)+"："+Str);
        }
        bfr.close();
    }
    public static void method3() throws IOException{
        //明确数据源：
        FileReader fr=new FileReader("F:\IOTest\TestA.txt");
        BufferedReader br=new BufferedReader(fr);
        //找到目的地：
        FileWriter fw=new FileWriter("F:\IOTest\RBQ\TestA.txt");
        BufferedWriter bw=new BufferedWriter(fw);
        String Str=null;
        while((Str=br.readLine())!=null){
            bw.write(Str);
            bw.newLine();
            bw.flush();
        }
        br.close();
        bw.close();
    }
}

留到08-23日做的作业：
package com.oracle.homework;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class HW5 {
    public static void main(String[] args) throws IOException {
        /*在电脑D盘下创建一个文件为HelloWorld.txt文件，判断他是文件还是目录，
        在创建一个目录IOTest,之后将HelloWorld.txt移动到IOTest目录下去；之后遍历IOTest这个目录下的文件！*/
        //创建HelloWorld.txt文件：
        File file=new File("d:\HelloWorld.txt");
        boolean IsSucc=file.createNewFile();
        if(IsSucc){
            System.out.println("创建文件成功！");
        }else{
            System.out.println("创建文件失败！");
        }
        //给该文件写入内容：
        FileWriter fwr=new FileWriter("Hello World！",true);
        //判断是文件还是目录：
        if(file.isDirectory()){
            System.out.println("该文件是一个目录！");
        }else{
            System.out.println("该文件是一个文件！");
        }
        //创建IOTest文件夹：
        File Dirc=new File("d:\IOTest");
        boolean IsDown=Dirc.mkdir();
        if(IsDown){
            System.out.println("创建文件夹成功！");
        }else{
            System.out.println("创建文件夹失败！");
        }
        //由于这是个文本文件，所以用字符流来进行复制：
        //明确数据源并装进Buffered高效流：
        FileReader fr=new FileReader("d:\HelloWorld.txt");
        BufferedReader br=new BufferedReader(fr);
        //找到目的地并装进Buffered高效流：
        FileWriter fw=new FileWriter("d:\IOTest\HelloWorld.txt");
        BufferedWriter bw=new BufferedWriter(fw);
        //定义char数组，并复制文件：
        char[] chars=new char[1024];
        while((br.read(chars))!=-1){
            bw.write(chars);
        }
        //复制成功后，删除HelloWorld.txt文件：
        file.delete();
        //关流：
        br.close();
        bw.close();
    }
}

package com.oracle.homework;
import java.io.File;
import java.io.IOException;
import java.util.Scanner;
public class HW6 {
    public static void main(String[] args) throws IOException {
        //递归实现输入任意目录，列出文件以及文件夹:
        //拿到用户输入的目录：
        Scanner scan=new Scanner(System.in);
        System.out.println("请输入文件夹名，F:\IOTest");
        String Str=scan.next();
        scan.close();
        //创建File对象：
        File file=new File(Str);
        //调用递归方法：
        getAll(file);
    }
    public static void getAll(File file) {
        File[] files=file.listFiles(new GetFilter());
        for(File Test:files) {
            if(Test.isDirectory()) {
                getAll(Test);
            }else {
                System.out.println(Test);
            }
        }
    }
}
//配合使用的FileFilter方法：
package com.oracle.homework;
import java.io.File;
import java.io.FileFilter;
public class GetFilter implements FileFilter {
    public boolean accept(File pathname){
        //一律return true读取所有文件！
        return true;
    }
}

package com.oracle.homework;
import java.io.File;
import java.io.IOException;
public class HW7 {
    public static void main(String[] args) throws IOException {
        //递归实现列出某目录下所有.java文件：
        //创建File对象：
        File file=new File("F:\IOTest");
        getAllJava(file);
    }
    //写遍历文件夹的对象：
    public static void getAllJava(File file) throws IOException{
        File[] files=file.listFiles(new DownFilter());
        for(File Str:files){
            if(Str.isDirectory()) {
                getAllJava(Str);
            }else {
                System.out.println(Str);
            }
        }
    }
}

package com.oracle.homework;
import java.io.File;
//继承刚才的GetFilter，并重写accept方法：
public class DownFilter extends GetFilter {
    public boolean accept(File pathname){
        if(pathname.isDirectory()){
            return true;
        }
        return pathname.getName().toLowerCase().endsWith(".java");
    }
}

IO流Very Important，好好学！