Java基础教程——字节流

Posted 2022-04-09 tigerlion

IO流

水流	特点
连续性	逝者如斯夫，不舍昼夜；
方向性	一江春水向东流。水往低处流。百川东到海，何时复西归？少壮不努力，老大徒伤悲！
源头尽头	唯有源头活水来；覆水难收

Java里的IO也有这样的特点。

IO：数据从硬盘流向内存（Input），或者从内存流向硬盘（Output）。

IO流分类：

按照流的流向来分：输入流、输出流。
|-输入流：读入内存。
|-输出流：写出到硬盘等设备。

按操作数据单元分：字节流、字符流
|-字节流：8位
|-字符流：16位

按流的角色分：节点流、处理流。
|-节点流：特定的IO设备（如硬盘），也叫低级流
|-处理流：经过封装的流，也叫高级流、包装流，可以消除不同节点流的差异（典型的装饰器模式）

Java的IO流有40多个类，高抽象层的基类有四个：

	字节流	字符流
输入流	InputStream	Reader
输出流	OutputStream	Writer

字节流

字节流：100100011010100010

可以操作所有文件，包括文本文件、视频、音频、压缩文件等等都可以用字节流读写。

两个重要的抽象类：

（1）抽象类 java.io.OutputStream，是输出字节流的所有类的超类

|--API方法摘要：
|--|--void write(byte[] b) 将 b.length 个字节从指定的 byte 数组写入此输出流。
|--|--abstract void write(int b) 将指定的字节写入此输出流。
|--|--void close() 关闭此输出流并释放与此流有关的所有系统资源。

（2）抽象类 java.io.InputStream，是输入字节流的所有类的超类

|--API方法摘要：
|--|--abstract int read()从输入流中读取数据的下一个字节。
|--|--int read(byte[] b) 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。
|--|--void close() 关闭此输入流并释放与该流关联的所有系统资源。

FileOutputStream写文件

// 文件输出流。完整地说，是文件字节输出流。
public class FileOutputStream extends OutputStream

步骤：
1.创建流对象
2.调用write方法，把数据写入文件
3.释放资源

import java.io.*;
public class 文件字节输出流 
    public static void main(String[] args) 
        File file = new File("文件字节输出流.txt"); // 创建文件对象
        try 
            // (1)构造：通过文件对象创建文件输出流对象
            FileOutputStream fos = new FileOutputStream(file);
            // (2)写入文件
            // (2.1)write(int b) 将"单个字节"写入到文件中
            for (int i = 49; i < 97; i++) 
                fos.write(i);
                fos.write(' ');
            
            // (2.2)write(byte[] b) 将"字节数组"中的数据全部写入文件
            byte[] buffer = "I Love Java,你呢?".getBytes();
            fos.write(buffer);
            // (3)关闭流
            fos.close();
         catch (IOException e) 
            e.printStackTrace();
        
    

追加：

使用构造方法：FileOutputStream(File file, boolean append)

            // 构造：通过文件对象创建文件输出流对象
            // 附加第二个参数true，指定进行文件追加，默认为不追加
            fos = new FileOutputStream(file, true);

回车换行：

CR（carriage return），回车，\\r
LF（line feed），换行，\\n

windows：\\r\\n
linux或unix:\\n
mac:\\r

FileInputStream读文件

public class FileInputStream extends InputStream

import java.io.*;
public class 文件字节输入流 
    static final int C_CONDITION = 2;
    public static void main(String[] args) 
        try 
            File file = new File("testRead.dat"); // 创建文件对象
            // 【1】创建输入流对象，相当于打开文件
            FileInputStream fis = new FileInputStream(file);
            if (C_CONDITION == 1) 
                // 【2】.read()：读取单个字节
                for (int i = 0; i < file.length(); i++) 
                    // 循环读取"字节"，转为字符输出，英文没问题
                    int read = fis.read();
                    char ch = (char) read;
                    System.out.print(ch);
                
                System.out.println();
             else 
                // 【2】.read(byte[] b)：读取文件中的数据到字节数组
                // 根据文件的字节长度创建字节数组
                long len = file.length();
                byte[] buf = new byte[(int) len];
                fis.read(buf);
                // 利用字节数组创建字符串
                String str = new String(buf);
                System.out.println(str);
            
            // 【3】关闭流
            fis.close();
         catch (FileNotFoundException fnfe) 
            System.out.println("文件打开失败。");
         catch (IOException ioe) 
            ioe.printStackTrace();
        
    

复制文件

package ahjava.io;
import java.io.*;
public class 复制文件 
    public static void main(String[] args) 
        字节流复制文件();
    
    static void 字节流复制文件() 
        File srcFile = new File("testRead.dat"); // 源文件对象
        File destFile = new File("testCopy.java"); // 目标文件对象
        if (destFile.exists()) 
            // 判断目标文件是否存在,存在则删除
            destFile.delete();
        
        // 目标文件不存在才复制
        try 
            destFile.createNewFile();
            // 创建文件输入/输出流对象
            FileInputStream fis = new FileInputStream(srcFile);
            FileOutputStream fos = new FileOutputStream(destFile);
            // 创建字节数组，作为临时缓冲
            byte[] buf = new byte[128];
            System.out.println("开始复制文件...");
            int len = -1;
            // 循环从文件输入流中读取数据
            while ((len = fis.read(buf)) != -1) 
                System.out.println(len);
                // 写入到文件输出流中
                fos.write(buf, 0, len);
            
            System.out.println("文件复制成功！");
            fis.close(); // 关闭流
            fos.close();
         catch (IOException e) 
            e.printStackTrace();
        
    

上面的代码有哪些风险？

改进版：

    static void 字节流复制文件2() 
        // 1.close()提取到finally中
        // 2.提取FilexxxStream对象
        // 3.初始化（否则不准close）
        // 4.close()时加判空语句
        FileInputStream fis = null;
        FileOutputStream fos = null;
        File srcFile = new File("testRead.dat"); // 源文件对象
        File destFile = new File("testCopy.java"); // 目标文件对象
        if (destFile.exists()) 
            // 判断目标文件是否存在,存在则删除
            destFile.delete();
        
        // 目标文件不存在才复制
        try 
            destFile.createNewFile();
            fis = new FileInputStream(srcFile);
            fos = new FileOutputStream(destFile);
            // 创建字节数组，作为临时缓冲
            byte[] buf = new byte[128];
            System.out.println("开始复制文件...");
            int len = -1;
            // 循环从文件输入流中读取数据
            while ((len = fis.read(buf)) != -1) 
                System.out.println(len);
                // 写入到文件输出流中
                fos.write(buf, 0, len);
            
            System.out.println("文件复制成功！");
            // 关闭流
         catch (IOException e) 
            e.printStackTrace();
         finally 
            if (fis != null) 
                try 
                    fis.close();
                 catch (IOException e) 
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                
                fis = null;
            
            if (fos != null) 
                try 
                    fos.close();
                 catch (IOException e) 
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                
                fos = null;
            
        
    

又臭又长！

Java 7异常处理写法：

try后面增加括号，其中定义流对象，该流对象仅在try中有效，执行完毕自动释放，不需要写finally。

try(流对象)
 catch (IOException e) 

具体代码如下：

    static void 字节流复制文件3() 
        File srcFile = new File("testRead.dat"); // 源文件对象
        File destFile = new File("testCopy.java"); // 目标文件对象
        if (destFile.exists()) 
            // 判断目标文件是否存在,存在则删除
            destFile.delete();
        
        // try(流对象)
        try (FileInputStream fis = new FileInputStream(srcFile);
                FileOutputStream fos = new FileOutputStream(destFile)) 
            destFile.createNewFile();
            // 创建字节数组，作为临时缓冲
            byte[] buf = new byte[128];
            System.out.println("开始复制文件...");
            int len = -1;
            // 循环从文件输入流中读取数据
            while ((len = fis.read(buf)) != -1) 
                System.out.println(len);
                // 写入到文件输出流中
                fos.write(buf, 0, len);
            
            System.out.println("文件复制成功！");
            // 关闭流
         catch (IOException e) 
            e.printStackTrace();
        
    

*Java9异常处理写法

觉得try里的代码太繁琐，try()中可以引入外部的变量：

FileInputStream fis = new FileInputStream(srcFile);
FileOutputStream fos = new FileOutputStream(destFile);
try  (fis;fos)...
// ↑ 理想状态，代码并不能这么写

然而，fis、fos本身需要抛异常，如果直接try...catch，这两个变量会变成另外的try中的局部变量；
如果把声明提取到try之外，try (fis;fos)又需要变量是final的

        FileInputStream fis = null;
        FileOutputStream fos = null;
        try 
            fis = new FileInputStream(srcFile);
            fos = new FileOutputStream(destFile);
         catch (FileNotFoundException e1) 
            e1.printStackTrace();
        
        try  (fis;fos) 

CopyFile.java:20: 错误: 用作 try-with-resources 资源的变量 fis 既不是最终变量, 也不是实际上的最终变量
try (fis;fos)
^
CopyFile.java:20: 错误: 用作 try-with-resources 资源的变量 fos 既不是最终变量, 也不是实际上的最终变量
try (fis;fos)

所以，fis和fos需要往外抛出异常，外部调用的地方又需要捕获异常。比不用此功能还要麻烦。可运行代码如下：

import java.io.*;
public class CopyFile
    public static void main(String[] args) 
        try 
            copyJDK9();
         catch (FileNotFoundException e) 
            e.printStackTrace();
        
    
    static void copyJDK9() throws FileNotFoundException 
        File srcFile = new File("testRead.dat");
        File destFile = new File("testCopy.java");
        if (destFile.exists()) 
            destFile.delete();
        

        FileInputStream fis = new FileInputStream(srcFile);
        FileOutputStream fos = new FileOutputStream(destFile);
        try  (fis;fos) 
            destFile.createNewFile();
            byte[] buf = new byte[128];
            System.out.println("start copy...");
            int len = -1;
            while ((len = fis.read(buf)) != -1) 
                System.out.println(len);
                fos.write(buf, 0, len);
            
            System.out.println("success");
         catch (IOException e) 
            e.printStackTrace();