转换流OutputStreamWriter 缓冲流

总结IO流结构

 

功能流：1.转换流 2.缓冲流 

 InputStreamReader : 读 in 输入节--符    看不懂转看的懂  

OutputStreamWriter  ：写 out 输出 符--节  看的懂转看不懂

转换流就是字符流 

转换流只有writer和reader 转换流没有字节流

功能：缓冲流 Buffered（加速缓冲的速度）

字节和字符流都可以加速

缓冲流分 字符和字节

字节：分字节输出流和字节输入流

字符：字符输出流和字符输入流

总结 ：流的规律 4个明确

1：是数据源还是数据目的

源：就是输入 InputStream  读取数据 Reader  

目的 ：输出 OutputStream  写入数据 Writer  根据需要明确要读还是要写

2：操作字节还是文本

源：字节 InputStream  文本 Reader  

目的 ：字节  OutputStream    文本 Writer 

3.数据所在具体设备

源设备：

 　　 硬盘：文件  File开头。

　　  内存：数组，字符串。

　　  键盘：System.in;

　　  网络：Socket

目的设备：

       硬盘：文件  File开头　　

　　内存：数组，字符串。

      屏幕：System.out;

       网络：Socket

4.是否需要功能

转换：转换流 InputStreamReader  和OutputStreamWriter

高效：缓冲区  Bufferedxxx

字节输入 InputStream                      字节输出OutputStream　　　　 　　　　　　　 字符输出流  Writer 　　　　　　　   　　　　　　　　  字符输入流 Reader

类读取数据FileInputStream　　　　文件输出流 FileOutputStream   　　　　　　　字符转字节  OutputStreamWriter　　　　　　　　　   字节转字符InputStreamReader

 

字节缓冲输入流 BufferedInputStream 字节缓冲输出流 BufferedOutputStream      写入文件 FileWriter   字符缓冲输出  BufferedWriter    文件读取 FileReader   字符缓冲输入 BufferedReader

   

转换输出流：字符流通向字节流的桥梁：可使用指定的字符编码表，将要写入流中的字符编码成字节 作用：将字符串按照指定的编码表转成字节，在使用字节流将这些字节写出去

package com.oracle.demo01;
\\转换输出流
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;

public class Demo01 {
    public static void main(String[] args) throws IOException {
//        明确目的地
        FileOutputStream fos=new FileOutputStream("F:\\java\\a.txt");
//        创建转换流对象  默认GBK
        OutputStreamWriter osw=new OutputStreamWriter(fos,"UTF-8");
//        写入字符
        osw.write("你好");
//        字符流都要刷新一下
        osw.flush();
//        释放资源
        osw.close();//这里需要关闭功能流，fos被osw调用，osw负责关闭，谁调用的，谁关闭
    }
}

转换输入流：字节流通向字符流的桥梁：它使用指定的字符编码表读取字节并将其解码为字符。它使用的字符集可以由名称指定或显式给定，或者可以接受平台默认的字符集

package com.oracle.demo01;
//转换输入流
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;

public class Demo02 {
    public static void main(String[] args) throws IOException {
//        明确数据源
        FileInputStream fis=new FileInputStream("F:\\java\\a.txt");
//        创建转换流对象
        InputStreamReader isr=new InputStreamReader(fis,"UTF-8");
//        一次读一个char数组
        int len=0;
        char[] ch=new char[1024];
//        开始读
        while((len=isr.read(ch))!=-1){  //!=-1  是结束标记，一次读个字符数组，当读完后得返回
            System.out.println(new String(ch,0,len));//用String转,如果不写 0,len  1024长度全部空格都写出来
//            释放资源
            isr.close();
        }
    }
}

 

转换流和子类区别：

 

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

 

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

 

InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"));//默认字符集。

 

InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"),"GBK");//指定GBK字符集。

 

FileReader fr = new FileReader("a.txt");

 

这三句代码的功能是一样的，其中第三句最为便捷。

 

　　注意：一旦要指定其他编码时，绝对不能用子类，必须使用字符转换流

 

用子类条件：

 

　　　　1、操作的是文件。2、使用默认编码。

 

总结：

 

字节--->字符 ： 看不懂的--->看的懂的。  要读。输入流。 InputStreamReader

 

字符--->字节 ： 看的懂的--->看不懂的。  需要写。输出流。 OutputStreamWriter

 

转换流复制

 

package com.oracle.demo01;
//转换流复制
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;

public class copy {
    public static void main(String[] args) throws IOException {
//        1.先明确数据源
        FileInputStream fis=new FileInputStream("F:\\java\\a.txt");
//        2.创建字符输入转换流
        InputStreamReader isr=new InputStreamReader(fis,"UTF-8");
//        3.明确目的地
        FileOutputStream fos=new FileOutputStream("F:\\java\\aa.txt");
//        4.创建字符输出转换流
        OutputStreamWriter osw=new OutputStreamWriter(fos,"UTF-8");
//        5.开始复制
        char[] ch=new char[1024];
        int len=0;
        while((len=isr.read(ch))!=-1){// 当它读不到数组的时候，返回-1
            osw.write(ch,0,len);
            osw.flush();//刷一次更新一次
        }
//        释放资源
        isr.close();
        osw.close();
    }
}

 

pm

 

字节缓冲输出流

package com.oracle.demo02;
import java.io.BufferedOutputStream;
//字节缓冲输出流
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class Demo01 {
    public static void main(String[] args) throws IOException {
//        明确目的地
        FileOutputStream fos=new FileOutputStream("f:\\java\\hello.txt");
//        创建缓冲区对象(给字节输出流添加缓冲区)
        BufferedOutputStream bos= new BufferedOutputStream(fos);//()里写谁 谁就是进缓冲区
//        写入
        bos.write("abc213".getBytes());
//        释放资源
        bos.close();
    }
}

字节缓冲输入流

package com.oracle.demo02;
//字节缓冲输入流
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

//字节输入流
public class Demo02 {
    public static void main(String[] args) throws IOException {
//        明确数据源
        FileInputStream fis=new FileInputStream("F:\\java\\hello.txt");
//        创建缓冲流
        BufferedInputStream bis=new BufferedInputStream(fis);
        int len=0;
        while((len=bis.read())!=-1){
            System.out.print((char)len);
        }
//        释放资源
        bis.close();
    }
}

字符缓冲输出流

package com.oracle.demo02;
//字符缓冲输出流
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class Demo03 {
    public static void main(String[] args) throws IOException {
//        明确目的地
        FileWriter fw=new FileWriter("F:\\java\\hello.txt");
//        创建字符输出缓冲流
        BufferedWriter bw=new BufferedWriter(fw);
        bw.write("你好啊胸大");
        bw.flush();
        bw.newLine();
        bw.write("我很好光头强");
//        释放资源
        bw.close();
    }
}

字符缓冲输入流

package com.oracle.demo02;
//字符缓冲输入流
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class readline {
    public static void main(String[] args) throws IOException {
//        明确数据源
        FileReader fr=new FileReader("f:\\java\\hello.txt");
//        创建字符输入缓冲流
        BufferedReader br=new BufferedReader(fr);
        /*String line=br.readLine();//读一行
        System.out.println(line);
        line=br.readLine();
        System.out.println(line);
        line=br.readLine();
        System.out.println(line);*/
        byte[] bytes=new byte[1024];
        String line=null;
        while((line=br.readLine())!=null){
            System.out.println(line);
        }
//        释放资源
        br.close();
    }
}

复制字节缓冲流

package com.oracle.demo02;
//复制字节缓冲流
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class Copy {
    public static void main(String[] args) throws IOException {
        Long start= System.currentTimeMillis();
//        明确数据源
        FileInputStream fis=new FileInputStream("f:\\java\\hello.txt");
//        创建字节输入缓冲流
        BufferedInputStream bis=new BufferedInputStream(fis);
//        明确目的地
        FileOutputStream fos=new FileOutputStream("f:\\java\nihao.txt");
//        创建字节输出缓冲流
        BufferedOutputStream bos=new BufferedOutputStream(fos);
        byte[] bytes=new byte[1024];
        int len=0;
        while((len=bis.read(bytes))!=-1){
            bos.write(bytes,0,len);
        }
        Long end=System.currentTimeMillis();
//        释放资源
        bis.close();
        bos.close();
        System.out.println("输出时间为:"+(end-start)+"毫秒值");
    }
}

复制行字节缓冲流

package com.oracle.demo02;
//复制行缓冲输出流
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 CopyLine {
    public static void main(String[] args) throws IOException {
//        明确数据源
        FileReader fr=new FileReader("f:\\java\\hello.txt");
//        创建字符输入缓冲流
        BufferedReader br=new BufferedReader(fr);
//        明确目的地
        FileWriter fw=new FileWriter("F:\\java\\nihao.txt");
        BufferedWriter bw=new BufferedWriter(fw);
        String line=null;
//        开始复制
//        读一行写一个字符串
        while((line=br.readLine())!=null){
            bw.write(line);
//            换行
            bw.newLine();
            bw.flush();
        }
//        释放资源
        bw.close();
        br.close();
    }
}

 流的操作规则：

把IO流进行了规律的总结(四个明确)：

1、 明确一：要操作的数据是数据源还是数据目的。

                 源：InputStream    Reader

                 目的：OutputStream Writer

　　先根据需求明确要读，还是要写。

 2、明确二：要操作的数据是字节还是文本呢？

                 源：

                         字节：InputStream

                         文本：Reader

                 目的：

                         字节：OutputStream

                         文本：Writer

已经明确到了具体的体系上。

3、明确三：明确数据所在的具体设备。

   源设备：

          硬盘：文件  File开头。

          内存：数组，字符串。

                         键盘：System.in;

                         网络：Socket

                 目的设备：

                         硬盘：文件  File开头。

                         内存：数组，字符串。

                         屏幕：System.out

                         网络：Socket

　　完全可以明确具体要使用哪个流对象。

4、明确四：是否需要额外功能呢？

                 额外功能：

                         转换吗？转换流。InputStreamReader OutputStreamWriter

                         高效吗？缓冲区对象。BufferedXXX