IO流

最新推荐文章于 2024-11-04 22:09:25 发布

原创最新推荐文章于 2024-11-04 22:09:25 发布 · 391 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#io流

JAVA学习专栏收录该内容

59 篇文章

订阅专栏

IO流分类

  IO流的分类：
        流向：
            输入流 读取数据
            输出流 写出数据
        数据类型：
            字节流
                字节输入流   读取数据    InputStream
                字节输出流   写出数据    OutputStream
            字符流
                字符输入流   读取数据    Reader
                字符输出流   写出数据    Writer

        注意：一般我们在探讨IO流的时候，如果没有明确说明按哪种分类来说，默认情况下是按照数据类型来分的。

FileOutputStream

方法

  public void write(int b):写一个字节
  public void write(byte[] b):写一个字节数组
  public void write(byte[] b,int off,int len):写一个字节数组的一部分

例

  需求：我要往一个文本文件中输入一句话："hello,io"

  分析：
        A:这个操作最好是采用字符流来做，但是呢，字符流是在字节流之后才出现的，所以，今天我先讲解字节流如何操作。
        B:由于我是要往文件中写一句话，所以我们要采用字节输出流。

  通过上面的分析后我们知道要使用：OutputStream
  但是通过查看API，我们发现该流对象是一个抽象类，不能实例化。
  所以，我们要找一个具体的子类。
  而我们要找的子类是什么名字的呢?这个时候，很简单，我们回想一下，我们是不是要往文件中写东西。
  文件是哪个单词：File
  然后用的是字节输出流，联起来就是：FileOutputStream
  注意：每种基类的子类都是以父类名作为后缀名。
        XxxOutputStream
        XxxInputStream
        XxxReader
        XxxWriter
  查看FileOutputStream的构造方法：
        FileOutputStream(File file) 
        FileOutputStream(String name)

  字节输出流操作步骤：
        A:创建字节输出流对象
        B:写数据
        C:释放资源

package cn.itcast_01;

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

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());
    }
}

几个常见问题

 1. 创建字节输出流对象了做了几件事情：
          A:调用系统功能去创建文件
          B:创建fos对象
          C:把fos对象指向这个文件

 2. 为什么一定要close()呢?
          A:让流对象变成垃圾，这样就可以被垃圾回收器回收了
          B:通知系统去释放跟该文件相关的资源  
           * 如何实现数据的换行?
 3. 为什么现在没有换行呢?因为你值写了字节数据，并没有写入换行符号。
        如何实现呢?写入换行符号即可呗。
        刚才我们看到了有写文本文件打开是可以的，通过windows自带的那个不行，为什么呢?
        因为不同的系统针对不同的换行符号识别是不一样的?
        windows:\r\n
        linux:\n
        Mac:\r
        而一些常见的个高级记事本，是可以识别任意换行符号的。

  4. 如何实现数据的追加写入?
        用构造方法带第二个参数是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) {
        // 分开做异常处理
        // FileOutputStream fos = null;
        // try {
        // fos = new FileOutputStream("fos4.txt");
        // } catch (FileNotFoundException e) {
        // e.printStackTrace();
        // }
        //
        // try {
        // fos.write("java".getBytes());
        // } catch (IOException e) {
        // e.printStackTrace();
        // }
        //
        // try {
        // fos.close();
        // } catch (IOException e) {
        // e.printStackTrace();
        // }

        // 一起做异常处理
        // 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();
                }
            }
        }
    }
}

FileInputStream

  字节输入流操作步骤：
  A:创建字节输入流对象
  B:调用read()方法读取数据，并把数据显示在控制台
  C:释放资源

  读取数据的方式：
  A:int read():一次读取一个字节
  B:int read(byte[] b):一次读取一个字节数组

/*int read():一次读取一个字节*/
package cn.itcast_02;

import java.io.FileInputStream;
import java.io.IOException;

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");

        // // 调用read()方法读取数据，并把数据显示在控制台
        // // 第一次读取
        // int by = fis.read();
        // System.out.println(by);
        // System.out.println((char) by);
        //
        // // 第二次读取
        // by = fis.read();
        // System.out.println(by);
        // System.out.println((char) by);
        //
        // // 第三次读取
        // by = fis.read();
        // System.out.println(by);
        // System.out.println((char) by);
        // // 我们发现代码的重复度很高，所以我们要用循环改进
        // // 而用循环，最麻烦的事情是如何控制循环判断条件呢?
        // // 第四次读取
        // by = fis.read();
        // System.out.println(by);
        // // 第五次读取
        // by = fis.read();
        // System.out.println(by);
        // //通过测试，我们知道如果你读取的数据是-1，就说明已经读取到文件的末尾了

        // 用循环改进
        // 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");

        // 读取数据
        // 定义一个字节数组
        // 第一次读取
        // byte[] bys = new byte[5];
        // int len = fis.read(bys);
        // // System.out.println(len);
        // // System.out.println(new String(bys));
        // // System.out.println(new String(bys, 0, len));
        // System.out.print(new String(bys, 0, len));
        //
        // // 第二次读取
        // len = fis.read(bys);
        // // System.out.println(len);
        // // System.out.println(new String(bys));
        // // System.out.println(new String(bys, 0, len));
        // System.out.print(new String(bys, 0, len));
        //
        // // 第三次读取
        // len = fis.read(bys);
        // // System.out.println(len);
        // // System.out.println(new String(bys));
        // // System.out.println(new String(bys, 0, len));
        // System.out.print(new String(bys, 0, len));
        //
        // // 第四次读取
        // len = fis.read(bys);
        // // System.out.println(len);
        // // System.out.println(new String(bys, 0, len));
        // System.out.print(new String(bys, 0, len));
        // // 代码重复了，用循环改进
        // // 但是，我不知道结束条件
        // // len = fis.read(bys);
        // // System.out.println(len);
        // // len = fis.read(bys);
        // // System.out.println(len);
        // // 如果读取到的实际长度是-1，就说明没有数据了

        // byte[] bys = new byte[115]; // 0
        // int len = 0;
        // while ((len = fis.read(bys)) != -1) {
        // System.out.print(new String(bys, 0, len));
        // // System.out.print(new String(bys)); //千万要带上len的使用
        // }

        // 最终版代码
        // 数组的长度一般是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();
    }
}

这里写图片描述

练习题

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

  数据源：
        e:\\林青霞.jpg --读取数据--FileInputStream
  目的地：
        mn.jpg--写出数据--FileOutputStream

package cn.itcast_03;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

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();
    }
}

字节缓冲区流

  通过定义数组的方式确实比以前一次读取一个字节的方式快很多，所以，看来有一个缓冲区还是非常好的。
  既然是这样的话，那么，java开始在设计的时候，它也考虑到了这个问题，就专门提供了带缓冲区的字节类。

  这种类被称为：缓冲区类(高效类)
      写数据：BufferedOutputStream 
             构造方法：
                 public BufferedOutputStream(OutputStream out)
                 public BufferedOutputStream(OutputStream out,int size)
      读数据：BufferedInputStream 
             构造方法：
                 public BufferedInputStream(InputStream in) 
                 public BufferedInputStream(InputStream in,int size)


  构造方法可以指定缓冲区的大小，但是我们一般用不上，因为默认缓冲区大小就足够了。

  为什么不传递一个具体的文件或者文件路径，而是传递一个OutputStream对象呢?
  原因很简单，字节缓冲区流仅仅提供缓冲区，为高效而设计的。但是呢，真正的读写操作还得靠基本的流对象实现。

package cn.itcast_05;

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;

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();
    }
}

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();
    }
}