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()中可以引入外部的变量：

FileInputStreamfis = 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();

}

FileInputStreamfis = 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();

}

}

}