Java——转换流，缓冲流

转换流

之前的FileOutputStream/FileInputStream保存的文件格式为当前系统的编码格式，如果我们想转换成其他的格式就要使用转换流。

一、输出转换流

OutputStreamWriter类

继承于Writer类，接受的是字符数组、字符串、int型，转换成不同形式编码格式的字节（字符==>不同格式的字节），然后存入文件中。

使用格式：

OutputStreamWriter(OutputStream out, String charsetName)

/*
 * 转换流对象OutputStreamWriter写文本
 * 采用UTF-8编码表写入
 */
public static void writeUTF()throws IOException{
	//创建字节输出流，绑定文件
	FileOutputStream fos = new FileOutputStream("c:\utf.txt");
	//创建转换流对象，构造方法保装字节输出流，并指定编码表是UTF-8
	OutputStreamWriter osw = new OutputStreamWriter(fos,"UTF-8");
	osw.write("你好");　　//可以接受字符数组，字符串，int型数据
	osw.close();
}

二、输入转换流

InputStreamReader类

继承于Reader类，接受的是不同形式编码格式的字节，根据不同的编码表转换成字符格式（不同格式的字节==>字符）

使用格式：

InputStreamReader(InputStream in,String charsetName)

/*
 *  转换流,InputSteamReader读取文本
 *  采用UTF-8编码表,读取文件utf
 */
public static void main(String[] args) throws IOException {
    //创建自己输入流,传递文本文件
    FileInputStream fos = new FileInputStream("/home/x54256/桌面/1.txt");
    //创建转换流对象,构造方法中,包装字节输入流,同时写编码表名
    InputStreamReader isr = new InputStreamReader(fos,"utf-8");
    int len = 0;
    char[] ch = new char[1024];
    while ((len = isr.read(ch))!=-1){
        //System.out.print((char)len);
        System.out.print(new String(ch,0,len));
    }
}

缓冲流

之前的读取文件中数据的操作，当读取数据量大的文件时，读取的速度会很慢，很影响我们程序的效率，为了提高速度，Java中提高了一套缓冲流，它的存在，可提高IO流的读写速度。

主要是缓冲一部分数据，然后在调用底层系统（Windows/Linux）进行IO操作

一、字节缓冲输出流

使用方法：

BufferedInputStream(InputStream in)

可以传递任意的字节输入流，传递是谁，就提高谁的效率。

public static void main(String[] args) throws IOException {
    //创建字节输出流
    FileOutputStream fos = new FileOutputStream("/home/x54256/桌面/1.txt");
    //创建字节输出流缓冲流的对象
    BufferedOutputStream bos = new BufferedOutputStream(fos);
    bos.write(79);
    bos.write("你好，世界！".getBytes());
    bos.write("你好，世界！".getBytes(),3,3);
    //bos.flush();
    bos.close();
}

二、字节缓冲输入流

使用方法：

BufferedInputStream(InputStream in)

可以传递任意的字节输入流,传递是谁,就提高谁的效率。

public static void main(String[] args) throws IOException {
    //创建输入流对象
    FileInputStream fis = new FileInputStream("/home/x54256/桌面/1.txt");
    //创建字节输入流的缓冲流对象
    BufferedInputStream bis = new BufferedInputStream(fis);

    byte[] b = new byte[10];
    int len = 0;
    while((len = bis.read(b))!=-1){
        System.out.println(new String(b,0,len));
    }
    bis.close();
}

三、字符缓冲输出流

使用方法：

BufferedWriter(Writer w)

可以传递任意的字符输出流，传递是谁,就提高谁的效率。

public static void main(String[] args) throws IOException {
    FileWriter fw = new FileWriter("/home/x54256/桌面/1.txt");
    BufferedWriter bw = new BufferedWriter(fw);
    bw.write(99);
    bw.newLine();   //新行，BufferedWriter的特有的方法，具有平台无关性
    bw.flush();     //字符流要刷进去

    bw.write("你好，世界！".toCharArray());
    bw.newLine();
    bw.flush();

    bw.write("你好，世界！");
    bw.newLine();
    bw.flush();

    bw.close();
    
}

四、字符缓冲输出流

使用方法：

BufferedWriter(Writer w)

可以传递任意的字符输入流，传递是谁,就提高谁的效率。

public static void main(String[] args) throws IOException {
    FileReader fr = new FileReader("/home/x54256/桌面/1.txt");
    BufferedReader br = new BufferedReader(fr);
    //int len = 0;
    //char[] c = new char[10];
    String line = null;
    //BufferedReader的特有方法readline
    while((line=br.readLine())!=null){
        System.out.println(line);
    }

//    while ( (len = br.read(c))!=-1 ){
//        System.out.print(new String(c,0,len));
//    }
//    while ( (len = br.read())!=-1 ){
//        System.out.print((char)len);
//    }
    br.close();
}

Copy文件

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

/*
 *  文件复制方式,字节流,一共4个方式
 *  1. 字节流读写单个字节                    125250 毫秒
 *  2. 字节流读写字节数组                    193    毫秒  OK
 *  3. 字节流缓冲区流读写单个字节     1210   毫秒
 *  4. 字节流缓冲区流读写字节数组     73     毫秒  OK
 */
public class Copy {
    public static void main(String[] args)throws IOException {
        long s = System.currentTimeMillis();
        copy_4(new File("c:\q.exe"), new File("d:\q.exe"));
        long e = System.currentTimeMillis();
        System.out.println(e-s);
    }
    /*
     * 方法,实现文件复制
     *  4. 字节流缓冲区流读写字节数组
     */
    public static void copy_4(File src,File desc)throws IOException{
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(src));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(desc));
        int len = 0 ;
        byte[] bytes = new byte[1024];
        while((len = bis.read(bytes))!=-1){
            bos.write(bytes,0,len);
        }
        bos.close();
        bis.close();
    }
    /*
     * 方法,实现文件复制
     *  3. 字节流缓冲区流读写单个字节
     */
    public static void copy_3(File src,File desc)throws IOException{
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(src));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(desc));
        int len = 0 ;
        while((len = bis.read())!=-1){
            bos.write(len);
        }
        bos.close();
        bis.close();
    }
    
    /*
     * 方法,实现文件复制
     *  2. 字节流读写字节数组
     */
    public static void copy_2(File src,File desc)throws IOException{
        FileInputStream fis = new FileInputStream(src);
        FileOutputStream fos = new FileOutputStream(desc);
        int len = 0 ;
        byte[] bytes = new byte[1024];
        while((len = fis.read(bytes))!=-1){
            fos.write(bytes,0,len);
        }
        fos.close();
        fis.close();
    }
    
    /*
     * 方法,实现文件复制
     *  1. 字节流读写单个字节
     */
    public static void copy_1(File src,File desc)throws IOException{
        FileInputStream fis = new FileInputStream(src);
        FileOutputStream fos = new FileOutputStream(desc);
        int len = 0 ;
        while((len = fis.read())!=-1){
            fos.write(len);
        }
        fos.close();
        fis.close();
    }
}

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

/*
 *  使用缓冲区流对象,复制文本文件
 *  数据源  BufferedReader+FileReader 读取
 *  数据目的 BufferedWriter+FileWriter 写入
 *  读取文本行, 读一行,写一行,写换行
 */
public class Copy_1 {
    public static void main(String[] args) throws IOException{
        BufferedReader bfr = new BufferedReader(new FileReader("c:\w.log"));    
        BufferedWriter bfw = new BufferedWriter(new FileWriter("d:\w.log"));
        //读取文本行, 读一行,写一行,写换行
        String line = null;
        while((line = bfr.readLine())!=null){
            bfw.write(line);
            bfw.newLine();
            bfw.flush();
        }
        bfw.close();
        bfr.close();
    }
}