Java基础教程——字节流

标签：for   cfile   throw   完整   流复制   也有   音频   不能   代码   

IO流

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

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

IO流分类：

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

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

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

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

字节流

字节流：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 

追加：

使用构造方法：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 

复制文件

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

Java基础教程——字节流

标签：for   cfile   throw   完整   流复制   也有   音频   不能   代码   

原文地址：https://www.cnblogs.com/tigerlion/p/11179223.html