Java学习之路(十二)：IO流

IO流的概述及其分类

IO流用来处理设备之间的数据传输，Java对数据的操作是通过流的方式
Java用于操作流的类都在IO包中

流按流向分为两种：输入流（读写数据）输出流（写数据）

流按操作类型分为两种：

字节流：字节流可以操作任何数据，因为在计算机中任何数据都是以字节的形式存储的
字符流：字符流只能操作纯字符数据，比较方便

常用的IO流的类

字节流的抽象父类：InputStream OutputStream

字符流的抽象方法：Reader Writer

InputStream实现类FileInputStream

InputStream是抽象类，表示字节输入流

FileInputStream从文件系统中的某个文件中获得输入字节。FileInputStream用于读取图像数据之类的原始字节流。要读取字符流，就要用FileReader

构造方法：

FileInputStream（File file）
FileInputStream（String name）

FileInputStream的构造方法可以传一个File对象，也可以传一个字符串路径

成员方法：

int read() 从此输入流中读取到一个数据字节

案例：读取一个txt文件数据

package null08031628;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.IOException;

public class Demo01 {

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

        // TODO Auto-generated method stub

        File file = new File("C:/Users/Administrator/Desktop/baiduyunpan.txt");

        FileInputStream fis = new FileInputStream(file);

        int i = ;

        while((i = fis.read()) != -){

            System.out.println(i);

        }

　　　　　fis.close();

} }

OutputStream实现类FileOutputStream文件输出流

文件输出流就是用于将数据写入File的输出流

案例：从一个文件读入数据写入另一个文件package null08031638;import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

public class Demo01 {

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

        // TODO Auto-generated method stub

        File filein = new File("C:/Users/Administrator/Desktop/baiduyunpan.txt");

        InputStream fis = new FileInputStream(filein);   //创建一个输入流

        File fileout = new File("C:/Users/Administrator/Desktop/baiduyunpan-2.txt");

        OutputStream fos = new FileOutputStream(fileout);   //创建一个输出流

        int i = 0;

        while((i=fis.read())!=-1){

            fos.write(i);

        }
　　　　　fos.close();
　　　　　fis.close();

    }

}

通过available()方法，进行字节数组拷贝（错误的，不推荐的，如果文件超级大怎么办？）

package null08031700;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

public class Demo01 {

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

        // TODO Auto-generated method stub

        FileInputStream input = new FileInputStream("C:/Users/Administrator/Desktop/baiduyunpan.txt");

        FileOutputStream out = new FileOutputStream("C:/Users/Administrator/Desktop/baiduyunpan-3.txt");

        byte[] bs = new byte[input.available()];//定义一个文件输入流那么大的字节数组

        input.read(bs); //一次性将数据写入到字节数组中

        out.write(bs); //一次性将文件写入

        input.close();

        out.close();

    }

}

自定义一个大小的数组，进行一个流的读写（正确的方法）

package null08031707;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

public class Demo01 {

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

        // TODO Auto-generated method stub

        FileInputStream input = new FileInputStream("C:/Users/Administrator/Desktop/baiduyunpan.txt");

        FileOutputStream out = new FileOutputStream("C:/Users/Administrator/Desktop/baiduyunpan-3.txt");

        byte[] bs = new byte[8*1024];

        int i = 0;

        while((i=input.read(bs))!=-1){

            out.write(i);

        }

        out.close();

        input.close();

    }

}

通过字节数组的方法操作流，其实就是相当于是创建了一个缓冲区

自带缓冲区的实现类BufferedInputStream和BufferedOutputStream

BufferedInputStream

内置了一个缓冲区（就是之前定义的那个数组）
从BufferedInputStream中读取一个字节时，BufferedInputStream会一次性的读入8192个，放在缓冲区，在返回给程序
程序再次读取时，就不会再从文件中取了，直接从缓冲区获取
知道缓冲区中的所有都被用过了，BufferedInputStream才重新从文件中读取8192个

BufferedOutputStream

内置了一个缓冲区（数组）
程序向流中写入字节时，不会直接写到文件，而是先写入缓冲区当中
知道缓冲区写满，BufferedOutputStream才会把缓冲区中的数据一次性写入文件

一个小小的例子：

package null08031732;

import java.io.BufferedInputStream;

import java.io.BufferedOutputStream;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

public class Demo01 {

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

        // TODO Auto-generated method stub

        FileInputStream fis = new FileInputStream("C:/Users/Administrator/Desktop/baiduyunpan.txt");

        BufferedInputStream bis = new BufferedInputStream(fis);

        FileOutputStream fos = new FileOutputStream("C:/Users/Administrator/Desktop/baiduyunpan-4.txt");

        BufferedOutputStream bos = new BufferedOutputStream(fos);

        int i;

        while((i=bis.read())!=-1){

            bos.write(i);

        }

        bis.close();

        bos.close();

    }

}

带Buffered的流和自己写的字节数组缓冲对比

字节写的数组在速度上回略胜一筹，因为自己写的读和写的操作都是在同一个数组之中
而Buffered操作的是两个数组，所以效率低于一个的

BufferedOutputStream中的一些方法

flush（）方法：用来刷新缓冲区，刷新后就可以再次写入了
close（）方法：关闭流，而且在关闭前后会刷新一次缓冲区

补充

字节流读写中文时乱码的问题

字节流读取中文：

字节流读取中文的问题
字节流在读取中文的时候有可能会读到半个中文，造成乱码

字节流写入中文的问题：

字节流直接操作的字节，所以写入中文的时候必须将字符串转换成字节数组
写出回车换行write（"\r\n".getBytes()）

流的标准处理异常代码1.6版本前

package null08041019;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

public class Demo01 {

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

        // TODO Auto-generated method stub

        FileInputStream fis = null;

        FileOutputStream fos = null;

        try{

            fis = new FileInputStream("");

            fos = new FileOutputStream("");

            int b;

            while((b=fis.read())!=-1){

                fos.write(b);

            }

        }finally{

            try{

                fis.close();

            }finally{

                fos.close();

            }

        }

    }

}

流的处理1.7版本

package null08041024;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

public class Demo01 {

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

        // TODO Auto-generated method stub

        try(

            //写在括号中的代码，执行完成后，会自动调用对象的close方法

            //能写在括号中的代码的类一定是要继承AutoCloseable接口的类

            FileInputStream fis = new FileInputStream("");

            FileOutputStream fos = new FileOutputStream("");

        ){

            int i;

            while((i=fis.read())!=-1){

                fos.write(i);

            }

        }

    }

}

一个图片加密的例子：

package null08041031;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.util.Scanner;

public class Demo01 {

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

        Scanner sc = new Scanner(System.in);

        System.out.println("请将图片放到和此文件的同级目录下");

        System.out.println("请输入要加密的文件名：");

        String fileName = sc.nextLine();

        System.out.println("请输入加密后的文件名：");

        String endFileName = sc.nextLine();

        System.out.println("请输入密码：");

        String pwd = sc.nextLine();

        int pwdInt = Integer.parseInt(pwd);

        try(

            FileInputStream fis = new FileInputStream(fileName);

            FileOutputStream fos = new FileOutputStream(endFileName);

            ){

            int i;

            while((i=fis.read())!=-1){

                fos.write(i^pwdInt);

            }

        }finally{

            System.out.println("加密结束");

        }

    }

}

代码