Java SE 学习笔记（十四）—— IO流（2）
目录
- 1 字节流
-
- 1.1 字节流写数据
-
- 1.1.1 创建字节输出流对象
- 1.1.2 字节流写数据
- 1.2 字节流读数据
-
- 1.2.1 创建字节输入流对象
- 1.2.2 字节流读数据
- 1.3 字节流复制文件
- 1.4 流的刷新与关闭
- 1.5 资源释放方式
-
- 1.5.1 try-catch-finally
- 1.5.2 try-with-resource
- 2 字符流
-
- 2.1 字符流概述
- 2.2 字符流写数据
- 2.3 字符流读数据
1 字节流
1.1 字节流写数据
1.1.1 创建字节输出流对象
- 字节流抽象基类
- InputStream：这个抽象类是表示字节输入流的所有类的超类
- OutputStream：这个抽象类是表示字节输出流的所有类的超类
- 子类名特点：子类名称都是以其父类名作为子类名的后缀
- 字节输出流
- FileOutputStream(String name)：创建文件输出流以指定的名称写入文件
- 使用字节输出流写数据的步骤
- 创建字节输出流对象(调用系统功能创建了文件，创建字节输出流对象，让字节输出流对象指向文件)
- 调用字节输出流对象的写数据方法
- 释放资源(关闭此文件输出流并释放与此流相关联的任何系统资源)
示例代码：
public static void main(String[] args) throws IOException {
//1.创建字节输出流的对象
FileOutputStream fos = new FileOutputStream("D:\\a.txt");
//FileOutputStream fos = new FileOutputStream(new File("D:\\a.txt"));
注意：
- 如果文件不存在，会帮我们自动创建出来.
- 如果文件存在，会把文件清空.
1.1.2 字节流写数据
示例代码：
public static void main(String[] args) throws IOException {
FileOutputStream fos = new FileOutputStream("bytestream\\a.txt");
/*fos.write(97);
fos.write(98);
fos.write(99);*/
/* byte[] bys = {97,98,99};
fos.write(bys);*/
byte [] bys = {97,98,99,100,101,102,103};
fos.write(bys,1,2); //98,99即写入bc
fos.close();
}
那么，现在有两个小问题
- 字节流写数据如何实现换行？
- windows:\r\n
- linux:\n
- mac:\r
- getBytes()是字符串的一个方法，可以将字符串转换为字节
- 字节流写数据如何实现追加写入？
- public FileOutputStream(String name,boolean append)
- 创建文件输出流对象以指定的名称写入文件。如果第二个参数为true ，则字节将写入文件的末尾而不是开头
示例代码：
public static void main(String[] args) throws IOException {
//第二个参数就是续写开关,如果没有传递,默认就是false,
//表示不打开续写功能,那么创建对象的这行代码会清空文件.
//如果第二个参数为true,表示打开续写功能
//那么创建对象的这行代码不会清空文件.
FileOutputStream fos = new FileOutputStream("bytestream\\a.txt",true);
fos.write(97);
//加一个换行
fos.write("\r\n".getBytes());
fos.write(98);
//加一个换行
fos.write("\r\n".getBytes());
fos.write(99);
//加一个换行
fos.write("\r\n".getBytes());
fos.write(100);
//加一个换行
fos.write("\r\n".getBytes());
fos.write(101);
//加一个换行
fos.write("\r\n".getBytes());
fos.close();
}
1.2 字节流读数据
1.2.1 创建字节输入流对象
字节输入流
- FileInputStream(String name)：通过打开与实际文件的连接来创建一个FileInputStream，该文件由文件系统中的路径名name命名
1.2.2 字节流读数据
字节输入流读取数据的步骤：
- 创建字节输入流对象
- 调用字节输入流对象的读数据方法
- 释放资源
1. 一次读一个字节数据
public static void main(String[] args) throws IOException {
//如果文件存在,那么就不会报错.
//如果文件不存在,那么就直接报错.
FileInputStream fis = new FileInputStream("bytestream\\a.txt");
int read = fis.read();
//一次读取一个字节,返回值就是本次读到的那个字节数据.
//也就是字符在码表中对应的那个数字.
//如果我们想要看到的是字符数据,那么一定要强转成char
System.out.println(read); // 97
System.out.println((char)read); //a
//释放资源
fis.close();
}
改进：使用循环
public static void main(String[] args) throws IOException {
FileInputStream fis = new FileInputStream("bytestream\\a.txt");
//文件中多个字节我怎么办?
/*while(true){
int i1 = fis.read(); 内容读取结束读取到空格时返回-1
System.out.println(i1);
}*/
int b;
while ((b = fis.read())!=-1){
System.out.println((char) b);
}
fis.close();
}
每个读取一个字节存在什么问题呢？
- 性能较慢
- 读取中文字符输出无法避免乱码问题
2. 一次读一个字节数组
一次读一个字节数组的方法：
public int read(byte[] b)：从输入流读取最多b.length个字节的数据- 返回的是读入缓冲区的总字节数，也就是实际的读取字节个数
注意：
hello.txt文件内容为：ab3abccdio为当前模块名
public static void main(String[] args) throws IOException {
FileInputStream fis = new FileInputStream("io/src/hello.txt");
byte[] bytes = new byte[3];
int len1 = fis.read(bytes);
System.out.println("读取了" + len1 + "字节"); // 读取了3字节
String s1 = new String(bytes);
System.out.println(s1); // ab3
int len2 = fis.read(bytes);
System.out.println("读取了" + len2 + "字节"); // 读取了3字节
String s2 = new String(bytes);
System.out.println(s2); // abc
int len3 = fis.read(bytes);
System.out.println("读取了" + len3 + "字节"); // 读取了2字节
// String s3 = new String(bytes);
// System.out.println(s3); // cdc
// 注意：上一次读取的是abc，这一次由于只读两个，所以只会覆盖前两个字符
// 读多少倒出多少
String s3 = new String(bytes, 0, 2);
System.out.println(s3); // cd
}
每次读取一个字节数组存在什么问题？
- 读取的性能得到了提升
- 读取中文字符输出无法避免乱码问题。
3. 一次读完全部字节
（1）定义一个与文件一样大的字节数组byte[] bytes=new byte[(int) f.length()]，一次性读完文件的全部字节，这样直接把文件数组全部读取到一个字节数组里可以避免乱码，但是如果文件过大，字节数组可能会引起内存溢出。
（2）官方为字节输入流 InputStream 提供了如下 API 可以直接把文件的全部数据读取到一个字节数组中
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
public class Test {
public static void main(String[] args) throws IOException {
File f = new File("io/src/hello.txt");
FileInputStream fis = new FileInputStream(f);
// 方法一
// byte[] bytes = new byte[(int) f.length()];
// int len = fis.read(bytes);
// System.out.println("读取了" + len + "字节"); // 读取了8字节
// System.out.println("文件的大小：" + f.length()+"字节"); // 文件的大小：8字节
// System.out.println(new String(bytes)); // ab3abccd
// 方法二
byte[] bytes1 = fis.readAllBytes();
System.out.println(new String(bytes1)); // ab3abccd
}
}
1.3 字节流复制文件
- 小文件复制
将C:\it\a.jpg的文件复制到模块 bytestream 下
public static void main(String[] args) throws IOException {
//创建了字节输入流,准备读数据.
FileInputStream fis = new FileInputStream("C:\\test\\a.jpg");
//创建了字节输出流,准备写数据.
FileOutputStream fos = new FileOutputStream("bytestream\\a.jpg");
int b;
while((b = fis.read())!=-1){
fos.write(b);
}
fis.close();
fos.close();
}
- 大文件复制
对于大文件的复制问题，字节流通过创建字节数组，可以一次读写多个数据
public static void main(String[] args) throws IOException {
FileInputStream fis = new FileInputStream("C:\\test\\a.avi");
FileOutputStream fos = new FileOutputStream("bytestream\\a.avi");
byte [] bytes = new byte[1024];// 该字节数组的大小是1024字节
int len;//本次读到的有效字节个数 --- 这次读了几个字节
while((len = fis.read(bytes))!=-1){ // 循环读取
fos.write(bytes,0,len);//0索引开始，读取len个字节
}
fis.close();
fos.close();
}
字节流适合做一切文件数据的拷贝吗？
- 任何文件的底层都是字节，拷贝是一字不漏的转移字节，只要前后文件格式，编码一致就没有任何问题。
1.4 流的刷新与关闭
以下两种方法能够让写出去的数据成功生效
1.5 资源释放方式
1.5.1 try-catch-finally
有如下代码：
try {
FileOutputStream fos = new FileOutputStream("a.txt");
fos.write(97);
fos.close();
}catch (IOException e){
e.printStackTrace();
}
我们如何操作才能让close方法一定执行呢？
异常处理的标准格式：
try{
可能出现异常的代码;
}catch(异常类名 变量名){
异常的处理代码;
}finally{
执行所有清除操作; // 在异常处理时提供finally块来执行所有的清除操作，比如IO流的释放资源，被finally控制的语句一定会执行，除非JVM退出
}
加异常处理后的代码如下：
public static void main(String[] args) {
FileOutputStream fos = null;
try {
//System.out.println(2/0);
fos = new FileOutputStream("D:\\a.txt");
//FileOutputStream fos = new FileOutputStream("D:\\a.txt");
//此时fos是局部变量，在finally里无法执行fos.close();
fos.write(97);
}catch(IOException e){
e.printStackTrace();
}finally {
//finally语句里面的代码,一定会被执行.
if(fos != null){//如果fos为null就不会和上述路径的文件产生关系，就不用关闭文件
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
finally 虽然可以用于释放资源，但是释放资源的代码过于繁琐
1.5.2 try-with-resource
JDK 7 以及 JDK 9 的 () 中 只能 放置资源对象，用完会自动关闭，自动调用资源对象的close方法关闭资源（即使出现异常也会做关闭操作）
- 什么是资源呢？
- 资源都是实现了 Closeable/AutoCloseable 接口的类对象
2 字符流
2.1 字符流概述
既然字节流可以操作所有文件，为什么要学习字符流？
- 如果利用字节流，把文本文件中的中文，读取到内存中，有可能出现乱码
- 如果利用字节流，把中文写到文本文件中，也有可能出现乱码
为什么字节流读取文本文件，可能会出现乱码？
- 因为字节流一次读一个字节，而不管GBK还是UTF-8一个中文都是多个字节，用字节流每次只能读其中的一部分，所以会出现乱码的问题
由于字节流操作中文不是特别的方便，所以Java就提供字符流（字符流 = 字节流 + 编码表）。字符流更适合操作中文，最小单位就是按照单个字符读写的。
2.2 字符流写数据
Writer: 用于写入字符流的抽象父类
FileWriter: 用于写入字符流的常用子类
构造方法：
成员方法：
public static void main(String[] args) throws IOException {
//创建字符输出流的对象
//FileWriter fw = new FileWriter(new File("charstream\\a.txt"));
FileWriter fw = new FileWriter("charstream\\a.txt");
//写一个字符
fw.write(97);
fw.write(98);
fw.write(99);
//写出一个字符数组
char [] chars1 = {97,98,99,100,101};
fw.write(chars1);
//写出字符数组的一部分
char [] chars2 = {97,98,99,100,101};
fw.write(chars2,0,3);
//写一个字符串
String line1 = "黑马程序员abc";
fw.write(line1);
//写一个字符串的一部分
String line2 = "黑马程序员abc";
fw.write(line2, 0, 2);
//释放资源
fw.close();
}
注意：
- 在创建字符输出流对象时，如果文件存在就清空，如果文件不存在就创建，但是要保证父级路径存在
- 写数据时，写出int类型的整数，实际写出的是整数在码表上对应的字母，写出字符串数据，是把字符串本身原样输出
2.3 字符流读数据
Reader: 用于读取字符流的抽象父类
FileReader: 用于读取字符流的常用子类
构造方法
成员方法
public static void main(String[] args) throws IOException {
//创建字符输入流的对象
// FileReader fr = new FileReader(new File("charstream\\a.txt"));
FileReader fr = new FileReader("charstream\\a.txt");
//读取数据
//一次读取一个字符
/* int ch;
while((ch = fr.read()) != -1){
System.out.println((char) ch);
}*/
//一次读取多个字符。
//创建一个数组
char [] chars = new char[1024];
int len;
//read方法还是读取，但是是一次读取多个字符
//他把读到的字符都存入到chars数组。
//返回值：表示本次读到了多少个字符。
while((len = fr.read(chars))!=-1){
System.out.println(new String(chars,0,len));
}
//释放资源
fr.close();
}
小结：
- 字节流适合做一切文件的拷贝
- 字符流适合做文本文件的操作（读写）
- 想要把文本文件中的数据读到内存中，使用字符输入流
- 想要把内存中的数据写到文本文件中，使用字符输出流