JavaSE之IO流

IO流

作用：用来处理设备间的数据传输问题。

常见应用：

• 文件复制
• 文件上传
• 文件下载

分类：

根据流向分为（以程序为中心）：

• 输入流：读取数据
• 输出流：写出数据

数据类型分为：

• 字节流
• 字符流：windows系统自带的笔记本打开是可以都懂的内容。

---

字节流写数据的步骤：

• 创建字节输出流对象
• 调用写数据的方法
• 释放资源

---

总结IO流图.jpg

---

FileOutputStream写数据加入异常处理

• 使用try....catch....finally

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class OutputExceptionDemo {
    public static void main(String[] args) throws FileNotFoundException {
          //初始化
            FileOutputStream fos = null;
         //加入try...catch...finally语句块
            try {
                fos = new FileOutputStream("b.txt");
                fos.write("hello World".getBytes());
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                //在释放资源之前进行非空判断
                if (fos != null) {
                }
                try {
                    if (fos != null) {
                        fos.close();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

---

各种IO流复制文本的效率比较

字节流四种方式复制文件效率测试

• 基本字节流一次读写一个字节
• 基本字节流一次读写一个字节数组
• 缓冲字节流一次读写一个字节
• 缓冲字节流一次读写一个字节数组

---

如下代码：

public class CopyAviTest {
    public static void main(String[] args) throws IOException {
        //记录开始时间
        long start = System.currentTimeMillis();
        
        method1();
        method2();
        method3();
        method4()；
        //记录结束时间
        long end = System.currentTimeMillis();
        System.out.println("共耗时："+(end-start)+"毫秒");
    }
    //缓冲字节流一次读写一个字节数组
    private static void method4() throws IOException {
        //封装数据源
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("d:\\复制图片.avi"));
        //封装目的地
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy.avi"));
        
        byte[] bys = new byte[1024];
        int len;
        while((len=bis.read(bys))!=-1) {
            bos.write(bys,0,len);
        }
        bos.close();
        bis.close();
    }
    //缓冲字节流一次读写一个字节
    private static void method3() throws IOException {
        //封装数据源
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("d:\\复制图片.avi"));
        //封装目的地
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy.avi"));
        
        int by;
        while((by=bis.read())!=-1) {
            bos.write(by);
        }
        bos.close();
        bis.close();
    }
    //基本字节流一次读写一个字节数组
    private static void method2() throws IOException {
        //封装数据源
        FileInputStream fis = new FileInputStream("d:\\复制图片.avi");
        //封装目的地
        FileOutputStream fos = new FileOutputStream("copy.avi");
        
        byte[] bys = new byte[1024];
        int len;
        while((len=fis.read(bys))!=-1) {
            fos.write(bys,0,len);
        }
        fos.close();
        fis.close();
    }
    //基本字节流一次读写一个字节
    private static void method1() throws IOException {
        //封装数据源
        FileInputStream fis = new FileInputStream("d:\\复制图片.avi");
        //封装目的地
        FileOutputStream fos = new FileOutputStream("copy.avi");

        int by;
        while((by=fis.read())!=-1) {
            fos.write(by);
        }
        fos.close();
        fis.close();
    }
}

结果：

method1() //基本字节流一次读写一个字节

共耗时：201387毫秒

---

method2() //基本字节流一次读写一个字节数组

共耗时：375毫秒

---

method3() //缓冲字节流一次读写一个字节

共耗时：181毫秒

---

method3() //缓冲字节流一次读写一个字节数组

共耗时：61毫秒

---

由此可见，加入缓冲区流后速度大大提高

---

---

字符流五种方式复制文件效率测试

• 基本字符流一次读写一个字符
• 基本字符流一次读写一个字符数组
• 缓冲字符流一次读写一个字符
• 缓冲字符流一次读写一个字符数组
• 缓冲字符串一次读写一个字符串

---

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

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

        long start = System.currentTimeMillis();
        method1();
//      method2();
//      method3();
//      method4();
//      method5();
        long end = System.currentTimeMillis();
        System.out.println("共耗时:"+(end-start)+"毫秒");
    }

//  基本字符流一次读写一个字符
    private static void method1() throws IOException {

        FileReader fr = new FileReader("窗里窗外.txt");

        FileWriter fw = new FileWriter("copy.txt");

        int ch;
        while ((ch = fr.read()) != -1) {
            fw.write(ch);
        }
        fr.close();
        fw.close();
    }

//  基本字符流一次读写一个字符数组
    private static void method2() throws IOException {

        FileReader fr = new FileReader("窗里窗外.txt");

        FileWriter fw = new FileWriter("copy.txt");

        char[] ch = new char[1024];
        int len;
        while ((len = fr.read(ch)) != -1) {
            fw.write(ch, 0, len);
        }
        fr.close();
        fw.close();
    }

//  缓冲字符流一次读写一个字符数组
    private static void method3() throws IOException {

        BufferedReader br = new BufferedReader(new FileReader("窗里窗外.txt"));

        BufferedWriter bw = new BufferedWriter(new FileWriter("copy.txt"));

        int ch;
        while ((ch = br.read()) != -1) {
            bw.write(ch);
        }
        br.close();
        bw.close();
    }

//  缓冲字符流一次读写一个字符数组
    private static void method4() throws IOException {

        BufferedReader br = new BufferedReader(new FileReader("窗里窗外.txt"));

        BufferedWriter bw = new BufferedWriter(new FileWriter("copy.txt"));

        char[] ch = new char[1024];
        int len;
        while ((len = br.read(ch)) != -1) {
            bw.write(ch, 0, len);
        }
        br.close();
        bw.close();
    }

//  缓冲字符流一次读写一个字符串
    private static void method5() throws IOException {

        BufferedReader br = new BufferedReader(new FileReader("窗里窗外.txt"));
        BufferedWriter bw = new BufferedWriter(new FileWriter("copy.txt"));

        String line;
        while ((line = br.readLine()) != null) {
            bw.write(line);
            bw.newLine();
            bw.flush();
        }
        br.close();
        bw.close();
    }
}

结果：

method1();//基本字符流一次读写一个字符

共耗时:30毫秒

---

method2(); //基本字符流一次读写一个字符数组

共耗时:10毫秒

---

method3();//缓冲字符流一次读写一个字符

共耗时:15毫秒

---

method4();//缓冲字符流一次读写一个字符数组

共耗时:11毫秒

---

method5();//缓冲字符串一次读写一个字符串

共耗时:16毫秒

---

由此可见，加入缓冲区效率大大提高