Java基础----【字节流、字符流】
主要内容
- IO流
- 字节流
- 字符流
- 异常处理
第一章 IO概述
1.1 什么是IO
生活中，你肯定经历过这样的场景。当你编辑一个文本文件，忘记了ctrl+s ，可能文件就白白编辑了。当你电脑上插入一个U盘，可以把一个视频，拷贝到你的电脑硬盘里。那么数据都是在哪些设备上的呢？键盘、内存、硬盘、外接设备等等。
我们把这种数据的传输，可以看做是一种数据的流动，按照流动的方向，以内存为基准，分为输入input 和输出output ，即流向内存是输入流，流出内存的输出流。
Java中I/O操作主要是指使用java.io包下的内容，进行输入、输出操作。输入也叫做读取数据，输出也叫做作写出数据。
1.2 IO的分类
根据数据的流向分为：输入流和输出流。
- 输入流 ：把数据从
其他设备上读取到内存中的流。 - 输出流 ：把数据从
内存中写出到其他设备上的流。
格局数据的类型分为：字节流和字符流。
- 字节流 ：以字节为单位，读写数据的流。
- 字符流 ：以字符为单位，读写数据的流。
1.3 IO的流向说明图解
1.4 顶级父类们
| 输入流 | 输出流 | |
|---|---|---|
| 字节流 | 字节输入流 InputStream |
字节输出流 OutputStream |
| 字符流 | 字符输入流 Reader |
字符输出流 Writer |
第二章 字节流
2.1 一切皆为字节
一切文件数据(文本、图片、视频等)在存储时，都是以二进制数字的形式保存，都一个一个的字节，那么传输时一样如此。所以，字节流可以传输任意文件数据。在操作流的时候，我们要时刻明确，无论使用什么样的流对象，底层传输的始终为二进制数据。
2.2 字节输出流【OutputStream】
java.io.OutputStream抽象类是表示字节输出流的所有类的超类，将指定的字节信息写出到目的地。它定义了字节输出流的基本共性功能方法。
public void close()：关闭此输出流并释放与此流相关联的任何系统资源。public void flush()：刷新此输出流并强制任何缓冲的输出字节被写出。public void write(byte[] b)：将 b.length字节从指定的字节数组写入此输出流。public void write(byte[] b, int off, int len)：从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流。public abstract void write(int b)：将指定的字节输出流。
小贴士：
close方法，当完成流的操作时，必须调用此方法，释放系统资源。
2.3 FileOutputStream类
OutputStream有很多子类，我们从最简单的一个子类开始。
java.io.FileOutputStream类是文件输出流，用于将数据写出到文件。
构造方法
public FileOutputStream(File file)：创建文件输出流以写入由指定的 File对象表示的文件。public FileOutputStream(String name)： 创建文件输出流以指定的名称写入文件。
当你创建一个流对象时，必须传入一个文件路径。该路径下，如果没有这个文件，会创建该文件。如果有这个文件，会清空这个文件的数据。
- 构造举例，代码如下：
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
public class FileOutputStreamTest1 {
public static void main(String[] args) throws FileNotFoundException {
// 1. 创建一个文件字节输出流对象
// 1.1 FileOutputStream(String name); 父目录存在, 文件才能写入成功.
FileOutputStream out = new FileOutputStream("D:/aaa.txt");
System.out.println(out);
// 1.2 FileOutputStream(File file); 说明 : 如果父目录不存在, 文件对象都会创建失败.
// 前提条件 : 必须要保证父目录的存在.
File file = new File("D:/aaa/bbb/aaa.txt");
// 1.2.1 先获取 file 对象的父目录
File parentFile = file.getParentFile();
// System.out.println("parentFile = " + parentFile);
// 1.2.2 判断父目录是否存在
if (parentFile.exists() == false) {
// 1.2.3 父目录不存在, 需要手动创建
parentFile.mkdirs();
}
FileOutputStream out2 = new FileOutputStream(file);
System.out.println(out2);
}
}
输出结果 :
out1 = java.io.FileOutputStream@1d251891
out2 = java.io.FileOutputStream@48140564
写出字节数据
- 写出字节：
write(int b)方法，每次可以写出一个字节数据，代码使用演示：
import java.io.FileOutputStream;
import java.io.IOException;
public class Test2 {
public static void main(String[] args) throws IOException {
// 需求 : 写出字节数据
FileOutputStream out = new FileOutputStream("a.txt");
// write(int) 一个字节一个字节写出
out.write(97);
out.write(98);
out.write(99);
// 关闭资源
out.close();
}
}
结果：
abc
小贴士：
- 虽然参数为int类型四个字节，但是只会保留一个字节的信息写出。
- 流操作完毕后，必须释放系统资源，调用close方法，千万记得。
- 写出字节数组：
write(byte[] b)，每次可以写出数组中的数据，代码使用演示：
import java.io.FileOutputStream;
import java.io.IOException;
public class Test2 {
public static void main(String[] args) throws IOException {
// 需求 : 写出字节数据
FileOutputStream out = new FileOutputStream("a.txt");
// write(byte[] b) 写入一个字节数组的长度
byte[] b = "黑马程序员".getBytes();
out.write(b);
// 关闭资源
out.close();
}
}
结果：
黑马程序员
- 写出指定长度字节数组：
write(byte[] b, int off, int len),每次写出从off索引开始，len个字节，代码使用演示：
import java.io.FileOutputStream;
import java.io.IOException;
public class Test2 {
public static void main(String[] args) throws IOException {
// 需求 : 写出字节数据
FileOutputStream out = new FileOutputStream("a.txt");
// write(byte[] b, int off, int len) 从一个字节数组的 0 位置开始, 取 2 个长度.
byte[] b = "abcdefg".getBytes();
out.write(b, 0, 2);
// 关闭资源
out.close();
}
}
结果：
ab
数据追加续写
经过以上的演示，每次程序运行，创建输出流对象，都会清空目标文件中的数据。如何保留目标文件中数据，还能继续添加新数据呢？
public FileOutputStream(File file, boolean append)： 创建文件输出流以写入由指定的 File对象表示的文件。public FileOutputStream(String name, boolean append)： 创建文件输出流以指定的名称写入文件。
这两个构造方法，参数中都需要传入一个boolean类型的值，true 表示追加数据，false 表示清空原有数据。这样创建的输出流对象，就可以指定是否追加续写了，代码使用演示：
import java.io.FileOutputStream;
import java.io.IOException;
public class Test2 {
public static void main(String[] args) throws IOException {
// 需求 : 写出字节数据
FileOutputStream out = new FileOutputStream("a.txt", true);
// write(byte[] b)
byte[] b = "我爱上海明珠塔".getBytes();
out.write(b);
// 关闭资源
out.close();
}
}
文件操作前：ab
文件操作后：ab我爱上海明珠塔
写出换行
Windows系统里，换行符号是\r\n 。把
以指定是否追加续写了，代码使用演示：
import java.io.FileOutputStream;
import java.io.IOException;
public class Test2 {
public static void main(String[] args) throws IOException {
// 需求 : 写出字节数据
FileOutputStream out = new FileOutputStream("a.txt", true);
// write(byte[] b)
// 换行 : 1. \r\n 2. System.lineSeparator();
byte[] b = "\r\n我爱上海黄浦江".getBytes();
out.write(b);
String lineSeparator = System.lineSeparator();
b = (lineSeparator + "我爱上海大传智").getBytes();
out.write(b);
// 关闭资源
out.close();
}
}
输出结果：
ab我爱上海明珠塔
我爱上海黄浦江
我爱上海大传智
- 回车符
\r和换行符\n：- 回车符：回到一行的开头（return）。
- 换行符：下一行（newline）。
- 系统中的换行：
- Windows系统里，每行结尾是
回车+换行，即\r\n；- Unix系统里，每行结尾只有
换行，即\n；- Mac系统里，每行结尾是
回车，即\r。从 Mac OS X开始与Linux统一。
2.4 字节输入流【InputStream】
java.io.InputStream抽象类是表示字节输入流的所有类的超类，可以读取字节信息到内存中。它定义了字节输入流的基本共性功能方法。
public void close()：关闭此输入流并释放与此流相关联的任何系统资源。public abstract int read()： 从输入流读取数据的下一个字节。public int read(byte[] b)： 从输入流中读取一些字节数，并将它们存储到字节数组 b中 。
小贴士：
close方法，当完成流的操作时，必须调用此方法，释放系统资源。
2.5 FileInputStream类
java.io.FileInputStream类是文件输入流，从文件中读取字节。
构造方法
FileInputStream(File file)： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的 File对象 file命名。FileInputStream(String name)： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的路径名 name命名。
当你创建一个流对象时，必须传入一个文件路径。该路径下，如果没有该文件,会抛出FileNotFoundException 。
- 构造举例，代码如下：
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
public class Test3 {
public static void main(String[] args) throws FileNotFoundException {
// FileInputStream(File file)： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的 File对象 file命名。
File file = new File("a.txt");
FileInputStream in = new FileInputStream(file);
System.out.println("in = " + in);
// FileInputStream(String name)： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的路径名 name命名。
FileInputStream in2 = new FileInputStream("a.txt");
System.out.println("in2 = " + in2);
}
}
输出结果 :
in = java.io.FileInputStream@1d251891
in2 = java.io.FileInputStream@48140564
读取字节数据
- 读取字节：
read方法，每次可以读取一个字节的数据，提升为int类型，读取到文件末尾，返回-1，代码使用演示：
import java.io.FileInputStream;
import java.io.IOException;
public class Test4 {
public static void main(String[] args) throws IOException {
// 1. 创建一个文件读取对象
FileInputStream in = new FileInputStream("a.txt");
// 2. read(); 一个一个字节读取数据
int read = in.read();
System.out.println("read = " + read);
read = in.read();
System.out.println("read = " + read);
read = in.read();
System.out.println("read = " + read);
read = in.read();
System.out.println("read = " + read);
// 3. close(); 关闭资源
in.close();
}
}
输出结果：
read = 97
read = 98
read = 99
read = -1
循环改进读取方式，代码使用演示：
import java.io.FileInputStream;
import java.io.IOException;
public class Test4 {
public static void main(String[] args) throws IOException {
// 1. 创建一个文件读取对象
FileInputStream in = new FileInputStream("a.txt");
// 2. read(); 一个一个字节读取数据
int read = -1;
while ((read = in.read()) != -1) {
System.out.println("read = " + read);
}
// 3. close(); 关闭资源
in.close();
}
}
输出结果：
read = 97
read = 98
read = 99
小贴士：
- 虽然读取了一个字节，但是会自动提升为int类型。
- 流操作完毕后，必须释放系统资源，调用close方法，千万记得。
2.6 字节流练习：图片复制
复制原理图解
复制案例实现1 : 读取一个字节,写入一个字节
复制图片文件，代码使用演示：
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class Test4 {
public static void main(String[] args) throws IOException {
long start = System.currentTimeMillis();
// 1.1 创建一个文件读取对象
FileInputStream in = new FileInputStream("D:\\1.jpg");
// 1.2 创建一个文件写出对象
FileOutputStream out = new FileOutputStream("1.jpg");
// 2. 读写数据
int read = -1;
while ((read = in.read()) != -1) {
out.write(read);
out.flush();
}
// 3. close(); 关闭资源
out.close();
in.close();
long end = System.currentTimeMillis();
System.out.println("共耗时 : " + (end - start) + "毫秒.");
}
}
输出结果 :
图片 : 共耗时 : 3821毫秒. 视频: 共耗时 : 51683毫秒.
小贴士：
流的关闭原则：先开后关，后开先关。
read方法的区别 : 读取字节数组
- 使用字节数组读取：
read(byte[] b)，每次读取b的长度个字节到数组中，返回读取到的有效字节个数，读取到末尾时，返回-1，代码使用演示：
说明 :
由于最后一次读取时，只读取了 len 的长度, 但是写入了整个字节数组 buf, 造成了数据的错误, 因为为, 读取多少长度, 就应该写入多少长度, 因为代码需要修正为 write(b, off, len);
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class Test5 {
public static void main(String[] args) throws IOException {
FileInputStream in = new FileInputStream("a.txt");
FileOutputStream out = new FileOutputStream("b.txt");
byte[] buf = new byte[8];
int len = -1;
while ((len = in.read(buf)) != -1) {
// out.write(buf);
out.write(buf, 0, len); // 写入数组中的数据, 从 0 (开头) 开始写, 写入读取的 len 长度.
}
/*
int len = in.read(buf);
System.out.println("Arrays.toString(buf) = " + Arrays.toString(buf));
System.out.println("len = " + len);
len = in.read(buf);
System.out.println("Arrays.toString(buf) = " + Arrays.toString(buf));
System.out.println("len = " + len);
*/
out.close();
in.close();
}
}
写入结果：
abcdefghijklmnopqrstuvwxyz
小贴士：
使用数组读取，每次读取多个字节，减少了系统间的IO操作次数，从而提高了读写的效率，建议开发中使用。
复制案例实现2 : 读取字节数组,写入字节数组
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class Test4 {
public static void main(String[] args) throws IOException {
long start = System.currentTimeMillis();
// 1.1 创建一个文件读取对象
FileInputStream in = new FileInputStream("D:\\1.jpg");
// 1.2 创建一个文件写出对象
FileOutputStream out = new FileOutputStream("1.jpg");
// 2. 读写数据
byte[] buf = new byte[1024];
int len = -1;
while ((len = in.read(buf)) != -1) {
out.write(buf, 0, len);
out.flush();
}
// 3. close(); 关闭资源
out.close();
in.close();
long end = System.currentTimeMillis();
System.out.println("共耗时 : " + (end - start) + "毫秒.");
}
}
输出结果 :
图片 : 共耗时 : 16毫秒. 视频 : 共耗时 : 79毫秒.
复制案例实现3 : 字节缓冲流包装in,out
构造方法
public BufferedInputStream(InputStream in)：创建一个 新的缓冲输入流。public BufferedOutputStream(OutputStream out)： 创建一个新的缓冲输出流。
构造举例，代码如下：
// 创建字节缓冲输入流
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("bis.txt"));
// 创建字节缓冲输出流
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("bos.txt"));
效率测试
import java.io.*;
public class Test4 {
public static void main(String[] args) throws IOException {
long start = System.currentTimeMillis();
// 1.1 创建一个文件读取对象
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\福利赠送.flv"));
// 1.2 创建一个文件写出对象
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("福利赠送.flv"));
// 2. 读写数据
byte[] buf = new byte[1024];
int len = -1;
while ((len = bis.read(buf)) != -1) {
bos.write(buf, 0, len);
bos.flush();
}
// 3. close(); 关闭资源
bos.close();
bis.close();
long end = System.currentTimeMillis();
System.out.println("共耗时 : " + (end - start) + "毫秒.");
}
}
输出结果 :
视频 : 共耗时 : 63毫秒.
第三章 字符流
当使用字节流读取文本文件时，可能会有一个小问题。就是遇到中文字符时，可能不会显示完整的字符，那是因为一个中文字符可能占用多个字节存储。所以Java提供一些字符流类，以字符为单位读写数据，专门用于处理文本文件。
3.1 字符输入流【Reader】
java.io.Reader抽象类是表示用于读取字符流的所有类的超类，可以读取字节信息到内存中。它定义了字节输入流的基本共性功能方法。
public void close()：关闭此流并释放与此流相关联的任何系统资源。public int read()： 从输入流读取一个字符。public int read(char[] cbuf)： 从输入流中读取一些字符，并将它们存储到字符数组 cbuf中 。
3.2 FileReader类
java.io.FileReader类是读取字符文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。
小贴士：
- 字符编码：字节与字符的对应规则。Windows系统的中文编码默认是GBK编码表。
idea中UTF-8
- 字节缓冲区：一个字节数组，用来临时存储字节数据。
构造方法
FileReader(File file)： 创建一个新的 FileReader ，给定要读取的File对象。FileReader(String fileName)： 创建一个新的 FileReader ，给定要读取的文件的名称。
当你创建一个流对象时，必须传入一个文件路径。类似于FileInputStream 。
- 构造举例，代码如下：
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
public class Test1 {
public static void main(String[] args) throws FileNotFoundException {
// 方式1. 创建一个字符输入流
File file = new File("a.txt");
FileReader reader = new FileReader(file);
System.out.println("reader = " + reader);
// 方式2. 创建一个字符输入流
FileReader reader2 = new FileReader("a.txt");
System.out.println("reader2 = " + reader2);
}
}
输出结果 :
reader = java.io.FileReader@48140564
reader2 = java.io.FileReader@58ceff1
读取字符数据
- 读取字符：
read方法，每次可以读取一个字符的数据，提升为int类型，读取到文件末尾，返回-1，循环读取，代码使用演示：
import java.io.FileReader;
import java.io.IOException;
public class Test2 {
public static void main(String[] args) throws IOException {
// 1. 创建一个字符输入流
FileReader reader = new FileReader("a.txt");
// 2. 读取数据
int read = -1;
while ((read = reader.read()) != -1) {
System.out.println((char) read);
}
// 3. 关闭资源
reader.close();
}
}
输出结果：
黑
马
程
序
员
小贴士：虽然读取了一个字符，但是会自动提升为int类型。
- 使用字符数组读取：
read(char[] cbuf)，每次读取b的长度个字符到数组中，返回读取到的有效字符个数，读取到末尾时，返回-1，代码使用演示：
import java.io.FileReader;
import java.io.IOException;
public class Test2 {
public static void main(String[] args) throws IOException {
// 1. 创建一个字符输入流
FileReader reader = new FileReader("a.txt");
// 2. 读取数据
char[] ch = new char[2];
int len = -1;
while ((len = reader.read(ch)) != -1) {
String str = new String(ch);
System.out.println(str);
}
// 3. 关闭资源
reader.close();
}
}
输出结果：
黑马
程序
员序
获取有效的字符改进，代码使用演示：
import java.io.FileReader;
import java.io.IOException;
public class Test2 {
public static void main(String[] args) throws IOException {
// 1. 创建一个字符输入流
FileReader reader = new FileReader("a.txt");
// 2. 读取数据
char[] ch = new char[2];
int len = -1;
while ((len = reader.read(ch)) != -1) {
String str = new String(ch, 0, len);
System.out.println(str);
}
// 3. 关闭资源
reader.close();
}
}
输出结果：
黑马
程序
员
3.3 字符输出流【Writer, FileWriter】
java.io.Writer抽象类是表示用于写出字符流的所有类的超类，将指定的字符信息写出到目的地。它定义了字节输出流的基本共性功能方法。
public abstract void close()：关闭此输出流并释放与此流相关联的任何系统资源。public abstract void flush()：刷新此输出流并强制任何缓冲的输出字符被写出。public void write(int c)：写出一个字符。public void write(char[] cbuf)：将 b.length字符从指定的字符数组写出此输出流。public abstract void write(char[] b, int off, int len)：从指定的字符数组写出 len字符，从偏移量 off开始输出到此输出流。public void write(String str)：写出一个字符串。
import java.io.FileWriter;
import java.io.IOException;
public class Test3 {
public static void main(String[] args) throws IOException {
// 1. 创建一个字符输出流
FileWriter writer = new FileWriter("b.txt");
// public void write(int c) ：写出一个字符。
writer.write(97);
// public void write(char[] cbuf)：将 b.length字符从指定的字符数组写出此输出流。
char[] cbuf = new char[]{'A', 'B', 'C', 'D', 'E'};
writer.write(cbuf);
// public abstract void write(char[] b, int off, int len) ：从指定的字符数组写出 len字符，从偏移量 off开始输出到此输出流。
writer.write(cbuf, 0, 2);
// public void write(String str) ：写出一个字符串。
writer.write("黑马程序员");
// 关闭资源
writer.close();
}
}
写出结果 :
aABCDEAB黑马程序员
3.4 续写和换行与读取：字符缓冲流
代码演示 :
// 创建字节缓冲输入流
BufferedReader br = new BufferedReader(new FileReader("br.txt", true));
// 创建字节缓冲输出流
BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt", true));
特有方法
字符缓冲流的基本方法与普通字符流调用方式一致，不再阐述，我们来看它们具备的特有方法。
- BufferedReader：
public String readLine(): 读一行文字。 - BufferedWriter：
public void newLine(): 写一行行分隔符,由系统属性定义符号。
newLine方法演示，代码如下：
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
public class Test4 {
public static void main(String[] args) throws IOException {
BufferedWriter writer = new BufferedWriter(new FileWriter("c.txt"));
// 写入数据三部曲 : (写入, 换行, 刷新)
writer.write("我爱上海明珠塔.");
writer.newLine();
writer.flush();
writer.write("我爱北京天安门.");
writer.newLine();
writer.flush();
writer.close();
}
}
输出结果:
我爱上海明珠塔.
我爱北京天安门.
续写 :
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
public class Test4 {
public static void main(String[] args) throws IOException {
BufferedWriter writer = new BufferedWriter(new FileWriter("c.txt", true));
// 写入数据三部曲 : (写入, 换行, 刷新)
writer.write("我爱广州小蛮腰.");
writer.newLine();
writer.flush();
writer.close();
}
}
输出结果 :
我爱上海明珠塔.
我爱北京天安门.
我爱广州小蛮腰.
小贴士：字符流，只能操作文本文件，不能操作图片，视频等非文本文件。
readLine方法演示，代码如下：
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class Test5 {
public static void main(String[] args) throws IOException {
// 1. 创建一个缓冲字符流对象
BufferedReader reader = new BufferedReader(new FileReader("c.txt"));
// 2. 一行一行读取
String line = reader.readLine();
System.out.println(line);
line = reader.readLine();
System.out.println(line);
line = reader.readLine();
System.out.println(line);
line = reader.readLine();
System.out.println(line);
// 3. 关闭资源
reader.close();
}
}
输出结果 :
我爱上海明珠塔.
我爱北京天安门.
我爱广州小蛮腰.
null
优化读取代码 :
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class Test5 {
public static void main(String[] args) throws IOException {
// 1. 创建一个缓冲字符流对象
BufferedReader reader = new BufferedReader(new FileReader("c.txt"));
// 2. 一行一行读取
String line = null;
while ((line = reader.readLine()) != null) {
System.out.println(line);
}
// 3. 关闭资源
reader.close();
}
}
输出结果 :
我爱上海明珠塔.
我爱北京天安门.
我爱广州小蛮腰.
第四章 IO异常的处理
JDK7前处理
之前的入门练习，我们一直把异常抛出，而实际开发中并不能这样处理，建议使用 try...catch...finally 代码块，处理异常部分，代码使用演示：
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
public class Test6 {
public static void main(String[] args) {
// 1. 定义一个 writer 对象
BufferedWriter writer = null;
try {
// 2. 初始化 writer 对象
writer = new BufferedWriter(new FileWriter("d.txt"));
// 写入三部曲 :
writer.write("黑马程序员");
writer.newLine();
writer.flush();
} catch (IOException e) {
e.printStackTrace();
} finally {
// 3. 关闭 writer 对象
if (writer != null) {
try {
writer.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
写入结果 :
黑马程序员
JDK7的处理
还可以使用JDK7优化后的try-with-resources 语句，该语句确保了每个资源在语句结束时关闭。所谓的资源（resource）是指在程序完成后，必须关闭的对象。
格式：
try (创建流对象语句，如果多个,使用';'隔开) {
// 读写数据
} catch (IOException e) {
e.printStackTrace();
}
代码使用演示：
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
public class Test6 {
public static void main(String[] args) {
// () 括号中解决的是 `流` 资源关闭的问题.
try (BufferedWriter writer = new BufferedWriter(new FileWriter("d.txt"))) {
// 写入三部曲 :
writer.write("黑马程序员");
writer.newLine();
writer.flush();
} catch (IOException e) {
e.printStackTrace();
}
}
}
写出结果 :
黑马程序员
JDK9的改进(了解内容)
JDK9中try-with-resources 的改进，对于引入对象的方式，支持的更加简洁。被引入的对象，同样可以自动关闭，无需手动close，我们来了解一下格式。
改进前格式：
import java.io.*;
public class Test7 {
public static void main(String[] args) {
// () 小括号中定义需要释放的资源对象.
try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:/1.jpg"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("1.jpg"))) {
// 读写操作 :
byte[] buf = new byte[1024];
int len = -1;
while ((len = bis.read(buf)) != -1) {
bos.write(buf, 0, len);
bos.flush();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
改进后格式：
import java.io.*;
public class Test7 {
public static void main(String[] args) throws FileNotFoundException {
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:/1.jpg"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("1.jpg"));
// () 小括号中定义需要释放的资源对象.
try (bis; bos) {
// 读写操作 :
byte[] buf = new byte[1024];
int len = -1;
while ((len = bis.read(buf)) != -1) {
bos.write(buf, 0, len);
bos.flush();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}