JAVASE基础 Item -- IO流之字节流

一、IO流概述

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

• 上传文件和下载文件

二、IO流分类

IO流的分类如果没有明确指定，默认指按照数据类型分。

2.1 按照数据流向

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

2.2 按照数据类型

• 字节流
• 字符流
  什么情况下使用哪种流呢?
  如果数据所在的文件通过windows自带的记事本打开并能读懂里面的内容，就用字符流。其他用字节流。
  如果你什么都不知道，就用字节流

三、IO流常用基类

• 字节流的抽象基类：
  InputStream ，OutputStream。
• 字符流的抽象基类：
  Reader ， Writer。
  注：由这四个类派生出来的子类名称都是以其父类名作为子类名的后缀。
  如：InputStream的子类FileInputStream。
  如：Reader的子类FileReader。

3.1 字节流写数据OutputStream

• FileOutputStream

1.FileOutputStream的构造方法

• FileOutputStream(File file)
• FileOutputStream(String name)

2.字节流写数据的方式

• public void write(int b)
• public void write(byte[] b)
• public void write(byte[] b,int off,int len)

package cn.itcast_01;import java.io.File;import java.io.FileNotFoundException;import java.io.FileOutputStream;import java.io.IOException;/* * IO流的分类： *      流向： *          输入流 读取数据 *          输出流 写出数据 *      数据类型： *          字节流 *              字节输入流   读取数据    InputStream *              字节输出流   写出数据    OutputStream *          字符流 *              字符输入流   读取数据    Reader *              字符输出流   写出数据    Writer *  *      注意：一般我们在探讨IO流的时候，如果没有明确说明按哪种分类来说，默认情况下是按照数据类型来分的。 *  * 需求：我要往一个文本文件中输入一句话："hello,io" *  * 分析： *      A:这个操作最好是采用字符流来做，但是呢，字符流是在字节流之后才出现的，所以，今天我先讲解字节流如何操作。 *      B:由于我是要往文件中写一句话，所以我们要采用字节输出流。 *  * 通过上面的分析后我们知道要使用：OutputStream * 但是通过查看API，我们发现该流对象是一个抽象类，不能实例化。 * 所以，我们要找一个具体的子类。 * 而我们要找的子类是什么名字的呢?这个时候，很简单，我们回想一下，我们是不是要往文件中写东西。 * 文件是哪个单词：File * 然后用的是字节输出流，联起来就是：FileOutputStream * 注意：每种基类的子类都是以父类名作为后缀名。 *      XxxOutputStream *      XxxInputStream *      XxxReader *      XxxWriter * 查看FileOutputStream的构造方法： *      FileOutputStream(File file)  *      FileOutputStream(String name) * * 字节输出流操作步骤： *      A:创建字节输出流对象 *      B:写数据 *      C:释放资源 */public class FileOutputStreamDemo {    public static void main(String[] args) throws IOException {        // 创建字节输出流对象        // FileOutputStream(File file)        // File file = new File("fos.txt");        // FileOutputStream fos = new FileOutputStream(file);        // FileOutputStream(String name)        FileOutputStream fos = new FileOutputStream("fos.txt");        /*         * 创建字节输出流对象了做了几件事情：         * A:调用系统功能去创建文件         * B:创建fos对象         * C:把fos对象指向这个文件         */        //写数据        fos.write("hello,IO".getBytes());        fos.write("java".getBytes());        //释放资源        //关闭此文件输出流并释放与此流有关的所有系统资源。        fos.close();        /*         * 为什么一定要close()呢?         * A:让流对象变成垃圾，这样就可以被垃圾回收器回收了         * B:通知系统去释放跟该文件相关的资源         */        //java.io.IOException: Stream Closed        //fos.write("java".getBytes());    }}

package cn.itcast_01;import java.io.FileOutputStream;import java.io.IOException;/* * 字节输出流操作步骤： * A:创建字节输出流对象 * B:调用write()方法 * C:释放资源 *  * public void write(int b):写一个字节 * public void write(byte[] b):写一个字节数组 * public void write(byte[] b,int off,int len):写一个字节数组的一部分 */public class FileOutputStreamDemo2 {    public static void main(String[] args) throws IOException {        // 创建字节输出流对象        // OutputStream os = new FileOutputStream("fos2.txt"); // 多态        FileOutputStream fos = new FileOutputStream("fos2.txt");        // 调用write()方法        //fos.write(97); //97 -- 底层二进制数据    -- 通过记事本打开 -- 找97对应的字符值 -- a        // fos.write(57);        // fos.write(55);        //public void write(byte[] b):写一个字节数组        byte[] bys={97,98,99,100,101};        fos.write(bys);        //public void write(byte[] b,int off,int len):写一个字节数组的一部分        fos.write(bys,1,3);        //释放资源        fos.close();    }}

package cn.itcast_01;import java.io.FileOutputStream;import java.io.IOException;/* * 如何实现数据的换行? *      为什么现在没有换行呢?因为你值写了字节数据，并没有写入换行符号。 *      如何实现呢?写入换行符号即可呗。 *      刚才我们看到了有写文本文件打开是可以的，通过windows自带的那个不行，为什么呢? *      因为不同的系统针对不同的换行符号识别是不一样的? *      windows:\r\n *      linux:\n *      Mac:\r *      而一些常见的个高级记事本，是可以识别任意换行符号的。 *  * 如何实现数据的追加写入? *      用构造方法带第二个参数是true的情况即可 */public class FileOutputStreamDemo3 {    public static void main(String[] args) throws IOException {        // 创建字节输出流对象        // FileOutputStream fos = new FileOutputStream("fos3.txt");        // 创建一个向具有指定 name 的文件中写入数据的输出文件流。如果第二个参数为 true，则将字节写入文件末尾处，而不是写入文件开始处。        FileOutputStream fos = new FileOutputStream("fos3.txt", true);        // 写数据        for (int x = 0; x < 10; x++) {            fos.write(("hello" + x).getBytes());            fos.write("\r\n".getBytes());        }        // 释放资源        fos.close();    }}

package cn.itcast_01;import java.io.FileNotFoundException;import java.io.FileOutputStream;import java.io.IOException;/* * 加入异常处理的字节输出流操作 */public class FileOutputStreamDemo4 {    public static void main(String[] args) {        // 分开做异常处理        // 一起做异常处理        // try {        // FileOutputStream fos = new FileOutputStream("fos4.txt");        // fos.write("java".getBytes());        // fos.close();        // } catch (FileNotFoundException e) {        // e.printStackTrace();        // } catch (IOException e) {        // e.printStackTrace();        // }        // 改进版        // 为了在finally里面能够看到该对象就必须定义到外面，为了访问不出问题，还必须给初始化值        FileOutputStream fos = null;        try {            // fos = new FileOutputStream("z:\\fos4.txt");            fos = new FileOutputStream("fos4.txt");            fos.write("java".getBytes());        } catch (FileNotFoundException e) {            e.printStackTrace();        } catch (IOException e) {            e.printStackTrace();        } finally {            // 如果fos不是null，才需要close()            if (fos != null) {                // 为了保证close()一定会执行，就放到这里了                try {                    fos.close();                } catch (IOException e) {                    e.printStackTrace();                }            }        }    }}

3.2 字节流写数据常见问题

1.创建字节输出流到底做了哪些事情?

2.数据写成功后，为什么要close()?

3.如何实现数据的换行?

4.如何实现数据的追加写入?

5.加入异常处理的IO流操作，该如何处理？

3.3 字节流写数据InputStream

• FileInputStream

1.FileInputStream的构造方法

• FileInputStream(File file)
• FileInputStream(String name)

2.FileInputStream的成员方法

• public int read()——一次读取一个字节

• public int read(byte[] b)——一次读取一个字节数组，每次可以读取多个数据，提高了操作效率。

这就像喝水一样：一次喝一滴水，一次喝一口水。

package cn.itcast_02;import java.io.FileInputStream;import java.io.IOException;/* * 字节输入流操作步骤： * A:创建字节输入流对象 * B:调用read()方法读取数据，并把数据显示在控制台 * C:释放资源 *  * 读取数据的方式： * A:int read():一次读取一个字节 * B:int read(byte[] b):一次读取一个字节数组 */public class FileInputStreamDemo {    public static void main(String[] args) throws IOException {        // FileInputStream(String name)        // FileInputStream fis = new FileInputStream("fis.txt");        FileInputStream fis = new FileInputStream("FileOutputStreamDemo.java");        // 用循环改进        // int by = fis.read();        // while (by != -1) {        // System.out.print((char) by);        // by = fis.read();        // }        // 最终版代码        int by = 0;        // 读取，赋值，判断        while ((by = fis.read()) != -1) {            System.out.print((char) by);        }        // 释放资源        fis.close();    }}

package cn.itcast_02;import java.io.FileInputStream;import java.io.IOException;/* * 一次读取一个字节数组：int read(byte[] b) * 返回值其实是实际读取的字节个数。 */public class FileInputStreamDemo2 {    public static void main(String[] args) throws IOException {        // 创建字节输入流对象        // FileInputStream fis = new FileInputStream("fis2.txt");        FileInputStream fis = new FileInputStream("FileOutputStreamDemo.java");        // 最终版代码        // 数组的长度一般是1024或者1024的整数倍        byte[] bys = new byte[1024];        int len = 0;        while ((len = fis.read(bys)) != -1) {            System.out.print(new String(bys, 0, len));        }        // 释放资源        fis.close();    }}

示例：字节流复制数据练习

复制数据的最基本思想：

• 数据源：读数据 ——InputStream
• 目的地：写数据——OutputStream

1.把c:\a.txt内容复制到d:\b.txt中

package cn.itcast_03;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.IOException;/* * 复制文本文件。 *  * 数据源：从哪里来 * a.txt    --  读取数据    --  FileInputStream  *  * 目的地：到哪里去 * b.txt    --  写数据     --  FileOutputStream *  * java.io.FileNotFoundException: a.txt (系统找不到指定的文件。) *  * 这一次复制中文没有出现任何问题，为什么呢? * 上一次我们出现问题的原因在于我们每次获取到一个字节数据，就把该字节数据转换为了字符数据，然后输出到控制台。 * 而这一次呢?确实通过IO流读取数据，写到文本文件，你读取一个字节，我就写入一个字节，你没有做任何的转换。 * 它会自己做转换。 */public class CopyFileDemo {    public static void main(String[] args) throws IOException {        // 封装数据源        FileInputStream fis = new FileInputStream("c:\\a.txt");        // 封装目的地        FileOutputStream fos = new FileOutputStream("d:\\b.txt");        int by = 0;        while ((by = fis.read()) != -1) {            fos.write(by);        }        // 释放资源(先关谁都行)        fos.close();        fis.close();    }}

2.把e:\林青霞.jpg内容复制到当前项目目录下的mn.jpg中

package cn.itcast_03;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.IOException;/* * 需求：把e:\\林青霞.jpg内容复制到当前项目目录下的mn.jpg中 *  * 数据源： *      e:\\林青霞.jpg --读取数据--FileInputStream * 目的地： *      mn.jpg--写出数据--FileOutputStream */public class CopyImageDemo {    public static void main(String[] args) throws IOException {        // 封装数据源        FileInputStream fis = new FileInputStream("e:\\林青霞.jpg");        // 封装目的地        FileOutputStream fos = new FileOutputStream("mn.jpg");        // 复制数据        int by = 0;        while ((by = fis.read()) != -1) {            fos.write(by);        }        // 释放资源        fos.close();        fis.close();    }}

3.把e:\哥有老婆.mp4复制到当前项目目录下的copy.mp4中（一次读一个字节，效率低下。）

package cn.itcast_03;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.IOException;/* * 需求：把e:\\哥有老婆.mp4复制到当前项目目录下的copy.mp4中 *  * 数据源： *      e:\\哥有老婆.mp4--读取数据--FileInputStream * 目的地： *      copy.mp4--写出数据--FileOutputStream */public class CopyMp4Demo {    public static void main(String[] args) throws IOException {        // 封装数据源        FileInputStream fis = new FileInputStream("e:\\哥有老婆.mp4");        // 封装目的地        FileOutputStream fos = new FileOutputStream("copy.mp4");        // 复制数据        int by = 0;        while ((by = fis.read()) != -1) {            fos.write(by);        }        // 释放资源        fos.close();        fis.close();    }}

3.4 字节缓冲流

字节流一次读写一个数组的速度明显比一次读写一个字节的速度快很多，这是加入了数组这样的缓冲区效果，java本身在设计的时候，也考虑到了这样的设计思想(装饰设计模式)，所以提供了字节缓冲区流

• 字节缓冲输出流
  
  • BufferedOutputStream

package cn.itcast_05;import java.io.BufferedOutputStream;import java.io.FileOutputStream;import java.io.IOException;/* * 通过定义数组的方式确实比以前一次读取一个字节的方式快很多，所以，看来有一个缓冲区还是非常好的。 * 既然是这样的话，那么，java开始在设计的时候，它也考虑到了这个问题，就专门提供了带缓冲区的字节类。 * 这种类被称为：缓冲区类(高效类) * 写数据：BufferedOutputStream * 读数据：BufferedInputStream *  * 构造方法可以指定缓冲区的大小，但是我们一般用不上，因为默认缓冲区大小就足够了。 *  * 为什么不传递一个具体的文件或者文件路径，而是传递一个OutputStream对象呢? * 原因很简单，字节缓冲区流仅仅提供缓冲区，为高效而设计的。但是呢，真正的读写操作还得靠基本的流对象实现。 */public class BufferedOutputStreamDemo {    public static void main(String[] args) throws IOException {        // BufferedOutputStream(OutputStream out)        // FileOutputStream fos = new FileOutputStream("bos.txt");        // BufferedOutputStream bos = new BufferedOutputStream(fos);        // 简单写法        BufferedOutputStream bos = new BufferedOutputStream(                new FileOutputStream("bos.txt"));        // 写数据        bos.write("hello".getBytes());        // 释放资源        bos.close();    }}

• 字节缓冲输入流
  
  • BufferedInputStream

package cn.itcast_05;import java.io.BufferedInputStream;import java.io.FileInputStream;import java.io.IOException;/* * 注意：虽然我们有两种方式可以读取，但是，请注意，这两种方式针对同一个对象在一个代码中只能使用一个。 */public class BufferedInputStreamDemo {    public static void main(String[] args) throws IOException {        // BufferedInputStream(InputStream in)        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(                "bos.txt"));        // 读取数据        // int by = 0;        // while ((by = bis.read()) != -1) {        // System.out.print((char) by);        // }        // System.out.println("---------");        byte[] bys = new byte[1024];        int len = 0;        while ((len = bis.read(bys)) != -1) {            System.out.print(new String(bys, 0, len));        }        // 释放资源        bis.close();    }}

示例：字节缓冲流复制数据练习

把d:\哥有老婆.mp4复制到当前项目目录下的copy.mp4中，四种方式比较复制效率。

package cn.itcast_06;import java.io.BufferedInputStream;import java.io.BufferedOutputStream;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.IOException;/* * 需求：把e:\\哥有老婆.mp4复制到当前项目目录下的copy.mp4中 *  * 字节流四种方式复制文件： * 基本字节流一次读写一个字节：   共耗时：117235毫秒 * 基本字节流一次读写一个字节数组： 共耗时：156毫秒 * 高效字节流一次读写一个字节： 共耗时：1141毫秒 * 高效字节流一次读写一个字节数组： 共耗时：47毫秒 */public class CopyMp4Demo {    public static void main(String[] args) throws IOException {        long start = System.currentTimeMillis();        // method1("e:\\哥有老婆.mp4", "copy1.mp4");        // method2("e:\\哥有老婆.mp4", "copy2.mp4");        // method3("e:\\哥有老婆.mp4", "copy3.mp4");        method4("e:\\哥有老婆.mp4", "copy4.mp4");        long end = System.currentTimeMillis();        System.out.println("共耗时：" + (end - start) + "毫秒");    }    // 高效字节流一次读写一个字节数组：    public static void method4(String srcString, String destString)            throws IOException {        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(                srcString));        BufferedOutputStream bos = new BufferedOutputStream(                new FileOutputStream(destString));        byte[] bys = new byte[1024];        int len = 0;        while ((len = bis.read(bys)) != -1) {            bos.write(bys, 0, len);        }        bos.close();        bis.close();    }    // 高效字节流一次读写一个字节：    public static void method3(String srcString, String destString)            throws IOException {        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(                srcString));        BufferedOutputStream bos = new BufferedOutputStream(                new FileOutputStream(destString));        int by = 0;        while ((by = bis.read()) != -1) {            bos.write(by);        }        bos.close();        bis.close();    }    // 基本字节流一次读写一个字节数组    public static void method2(String srcString, String destString)            throws IOException {        FileInputStream fis = new FileInputStream(srcString);        FileOutputStream fos = new FileOutputStream(destString);        byte[] bys = new byte[1024];        int len = 0;        while ((len = fis.read(bys)) != -1) {            fos.write(bys, 0, len);        }        fos.close();        fis.close();    }    // 基本字节流一次读写一个字节    public static void method1(String srcString, String destString)            throws IOException {        FileInputStream fis = new FileInputStream(srcString);        FileOutputStream fos = new FileOutputStream(destString);        int by = 0;        while ((by = fis.read()) != -1) {            fos.write(by);        }        fos.close();        fis.close();    }}