Java中IO流——详解字节流之FileOutputStream和FileInputStream

---

前言

我们之前学习了Java中的异常机制和File类，现在正式进入IO流的学习。

一、Java流的概述

文件通常是由一连串的字节或字符构成。

• 组成文件的字节序列称为字节流。
• 组成文件的字符序列称为字符流。

Java中根据流的方向可以分为输入流和输出流。

• 输入流是将文件或其它输入设备的数据加载到内存的过程
• 输出流是将内存中的数据保存到文件或其他输出设备。
  

二、常用字节流分类

1.字节输出输入流

1.FileOutputStream

1.FileOutputStream文件输出流:文件输出流是用于将数据写入file。
2.构造方法、write()方法、追加写入、释放流等使用如下：

public class 字节输出流之FileOutputStream {
     
    //FileOutputStream 文件输出流:文件输出流是用于将数据写入file
    public static void main(String[] args) throws IOException {
     
        File file = new File("a.txt");
//一、构造方法
        //1.构造方法一：创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
            //注意：创建字节输出流对象做了哪几件事？
        FileOutputStream fileOutputStream = new FileOutputStream(file);
        //2.构造方法二：创建一个向具有指定名称的文件中写入数据的输出文件流。
        FileOutputStream fileOutputStream1 = new FileOutputStream("b.txt");
//二、三个write()方法
        //1.write(int b)——将指定字节写入此文件输出流。
        fileOutputStream.write(97);
        fileOutputStream.write(98);
        fileOutputStream.write(99);
             //超过一个字节，丢弃多余字节
        fileOutputStream.write(200);

        //2.write(byte[] b) 将 b.length 个字节从指定 byte 数组写入此文件输出流中。
        byte[] bytes = new byte[]{
     100,101,102,103};
        fileOutputStream.write(bytes);

        //3.write(byte[] b, int off, int len) 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流。
        fileOutputStream.write(bytes,0,1);//参数1是元素索引，参数2是个数
        //补充：利用getBytes()方法获取一个汉字的十进制表示
        byte[] bytes1 = "我".getBytes();
        fileOutputStream.write(bytes1);
        byte[] bytes2 = "我爱你悬悬小".getBytes();
        fileOutputStream.write(bytes2);

//三、追加写入
		//构造方法中的参数2，true代表追加写入。默认为false  
        FileOutputStream fileOutputStream2 = new FileOutputStream("c.txt",true);
        fileOutputStream2.write(bytes2);
        fileOutputStream2.write("\r\n".getBytes());


//四、释放流
        //流使用完毕之后，一定记得释放资源
        fileOutputStream.close();
        fileOutputStream1.close();

    }
}

2.FileInputStream

1.FileInputStream 从文件系统中的某个文件中获得输入字节。
2.构造方法、read()方法、释放流等使用如下

public class 字节输入流之FileInputStream {
     
    //FileInputStream 从文件系统中的某个文件中获得输入字节。
    public static void main(String[] args) throws IOException {
     
        //1.构造方法一：FileInputStream(File file)
        //          通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定。
        FileInputStream fileInputStream = new FileInputStream("a.txt");//输入流关联的文件必须存在！！

        //读入文件中的数据
        //1.read()--从此输入流中读取一个数据字节。如果读取不到，返回-1.（所以我们可以使用-1，判断文件是否读取完毕）
        int read = fileInputStream.read();
        System.out.println((read));
            //将int强转成char类型
        char ch=(char)read;
        System.out.println(ch);
        //2.read(byte[] b)——从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中
        FileInputStream fileInputStream1 = new FileInputStream("c.txt");
            //一次读取多个字节，填到字节数组中，返回的是读取到的有效字节个数。
        byte[] bytes = new byte[1024];//定义了字节数组充当缓冲区
        int read1 = fileInputStream1.read(bytes);
        System.out.println("实际读取到的字节个数"+read1);
            //输出内容:字节数组转化为字符串
        String s = new String(bytes,0,read1);
        System.out.println(s);

        //3.read(byte[] b, int off, int len)——从此输入流中将最多 len 个字节的数据读入一个 byte 数组中。
        int len = fileInputStream1.read(bytes, 0, 3);//只填充3个字节


        //释放资源
        fileInputStream.close();
        fileInputStream1.close();


    }
}

3.复制小练习

1. demo1，循环一次读取一个字节，写入一个字节。（效率低）

public class 文件复制 {
     
    public static void main(String[] args) throws IOException {
     
        //1.封装源文件
        File F = new File("c.txt");
        FileInputStream in = new FileInputStream(F);
        //2.封装目标文件
        FileOutputStream out = new FileOutputStream(new File("C:\\Users\\46188\\Desktop\\", F.getName()));
        //3.复制，循环一次读取一个字节，写入一个字节完成复制（效率低）
        while(true){
     
            int by = in.read();
            if(by==-1){
     
                break;
            }
            out.write(by);
        }
        //4.释放资源
        in.close();
        out.close();

    }
}

2. demo2，使用字符数组充当缓冲区

public class 文件复制2 {
     
    public static void main(String[] args) throws IOException {
     
        File FF = new File("小悬悬.txt");
        //1.封装源文件
        FileInputStream input = new FileInputStream(FF);
        //2.封装目标文件
        FileOutputStream output = new FileOutputStream(new File("C:\\Users\\46188\\Desktop\\", FF.getName()));
        //3.使用字节数组进行复制
            //创建字符数组充当缓冲区
        while (true){
     
            byte[] bytes1 = new byte[1024 * 8];
            int len = input.read(bytes1);//输出文件的内容填充到字符数组中，返回内容的字节个数
            if(len==-1){
     
                break;
            }
            output.write(bytes1, 0, len);//输入数组
        }
        input.close();
        output.close();


    }
}

4.异常捕获

• 标准的流的异常处理

public class 流的异常处理 {
     
    public static void main(String[] args) {
     
        FileOutputStream fileOutputStream0 =null;
        try {
     
            fileOutputStream0 = new FileOutputStream("e.txt");
            fileOutputStream0.write("小悬悬".getBytes());

        } catch (IOException e) {
     
            e.printStackTrace();
        }finally {
     
            //释放资源
            try {
     
                if(fileOutputStream0!=null){
     
                    fileOutputStream0.close();
                }
            } catch (IOException e) {
     
                e.printStackTrace();
            }
        }
        System.out.println("下面的代码");

    }
}

总结

关于字节流中的FileOutputStream和FileInputStream不难掌握，其他流对象的原理和这两个是相同的，所以作为重点掌握。