12.8号知识点
1、IO流概述
I:input 输入(读取)把硬盘中的数据,读取到内存中使用
O:output 输出(写入)把内存中的数据写入到硬盘中保存
流:数据(字符,字节)1字符=2字节 1字节=8二进制位
2、字节流
2.1 一切皆为字节
一切文件数据存储时,都是以二进制数字的形式保存,都是一个一个字节,传输时也一样;字节流可以传输任意文件数据,操作流时,无论使用什么样的流对象,底层都是以二进制数据进行传输。
2.2 字节输出流 OutputStream
java.io.OutputStream抽象类
此抽象类是表示输出字节流的所有类的超类
2.2.1成员方法
void close()
关闭此输出流并释放与此流有关的所有系统资源。
void flush()
刷新此输出流并强制写出所有缓冲的输出字节。
void write(byte[] b)
将 b.length 个字节从指定的 byte 数组写入此输出流。
一次写多个字节:
如果写的第一个字节是正数(0-127),那么显示的时候查ASCII表
如果写的第一个字节是负数,那第一个字节和第二个字节会组成一个中文显示,查询系统默认编码表
void write(byte[] b, int off, int len)
将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。
参数:
byte[] b:字节数组
int off:数组开始的索引
int len:要写入的字节个数
abstract void write(int b)
将指定的字节写入此输出流。
2.3 文件字节输出流 FileOutputStream
java.io.FileOutputStream extends OutputStream
作用:把内存中的数据写入到硬盘的文件中
构造方法:
FileOutputStream(File file)
创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
FileOutputStream(String name)
创建一个向具有指定名称的文件中写入数据的输出文件流。
参数:
String name:目的地是一个文件的路径
File file:目的地是一个文件
构造方法的作用:
- 创建一个FileOutputStream对象
- 会根据构造方法中传递的文件/文件路径,创建一个空的文件
- 会把FileOutputStream对象指向创建好的文件
使用步骤: - 创建一个FileOutputStream对象
- 调用FileOutputStream对象中的方法write,把数据写入到文件中
- 释放资源(流使用会占用一定的内存,使用完清空可以保证程序的效率)
2.3.1 写入字符串的方法
可以使用String类中的方法把字符串转换为字节数组
byte[] getBytes() 把字符串转换为字节数组
2.3.2 追加写
FileOutputStream(String name, boolean append)
创建一个向具有指定 name 的文件中写入数据的输出文件流。
FileOutputStream(File file, boolean append)
创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
参数:
boolean append:true创建对象不会覆盖源文件,继续在文件末尾追加数据
false:创建一个新文件,覆盖源文件
2.3.3 换行写
windows:\r\n
linux:/n
mac:/r
2.4 字节输入流 InputStream
java.io.InputStream抽象类是表示字节输入流的所有类的超类
定义了所有子类共性的方法:
int read():从输入流中读取数据的一个字节,读取不到文件会返回-1
int read(byte[] b) :从输入流中读取一定数量的字节,并将其存储在缓冲区数组b中 ;返回值int是读取的有效字节个数
void close():关闭此输入流并释放与该流关联的所有系统资源
2.4.1 文件字节输入流 FileInputStream
java.io.FileInputStream extends InputStream
作用:把硬盘文件中的数据,读取到内存中使用
构造方法:
FileInputStream(String name)
FileInoutStream(File file)
参数:
String name:文件的路径
File file:文件对象
作用:
- 会创建一个FileInputStream对象
- 会把FileInputStream对象指定构造方法中要读取的文件
使用步骤: - 创建FileInputStream对象,构造方法中绑定要读取的数据源
- 使用FileInputStream对象中的发昂发read,读取文件
- 释放资源
字节输入输出流代码示例:
public static void main(String[] args) throws IOException {
FileOutputStream fileOutputStream = new FileOutputStream("d:\\abc\\a\\java.txt");
byte[] b = {97, 98, 99};
fileOutputStream.write(b);
fileOutputStream.close();
FileInputStream fis = new FileInputStream(new File("d:\\abc\\a\\java.txt"));
/*
// 一次读取一个字节
int len = 0;
// boolean表达式(len = fis.read()) != -1这样写是因为每调用一次read方法,指针就往后移动一位
while ((len = fis.read()) != -1) {
System.out.println(len);
}
*/
// 一次读取多个字节
// fis.read(byte[] b) 传入一个字节数组,返回读取的字节个数;如果没有要读取的字节,返回-1
byte[] bytes = new byte[1024]; // 一般放1024个(1kb)
int len = 0;
while ((len = fis.read(bytes)) != -1) {
// 使用String类的构造方法取有效数据
// String(byte[] bytes, int offset, int length)
// 通过使用平台的默认字符集解码指定的 byte 子数组,构造一个新的 String。
System.out.println(new String(bytes, 0, len));
}
}
2.5 字节流读取中文
使用字节流读取中文文件
1个中文:GBK:占用两个字节 UTF-8:占用三个字节
使用字节输入输出流复制文件:
代码示例:
public static void main(String[] args) {
try (FileInputStream fis = new FileInputStream("C:\\Users\\dmhxm\\Desktop\\image\\77db(1).mp4");
FileOutputStream fos = new FileOutputStream(new File("D:\\abc\\a\\77db(1).mp4"));){
byte[] c = new byte[1024];
int len = 0;
while ((len = fis.read(c)) != -1) {
fos.write(c, 0, len);
}
} catch (IOException e) {
e.printStackTrace();
}
}
3、 字符流
3.1 字符输入流Reader
java.io.Reader是字符输入流最顶层的父类,定义了一些共性的成员 方法,是一个抽象类
共性的成员方法:
int read() :读取单个字符并返回
int read(char[] cbuf):一次读取多个字符,将字符读入数组
void close():关闭字符流,释放资源
3.2 文件字符输入流 FileReader
java.io.FileReader extends InputStreamReader extends Reader
FileReader : 文件字符输入流
作用:把硬盘中的数据以字符的方式读取到内存中
构造方法:
FileReader(String fileName)
FileReader(File file)
参数:读取文件的数据源
String fileName:文件路径
File file:一个文件对象
FileReader构造方法的作用:
1.创建一个FileReader对象
2. 会把FileReader对象指向要读取的文件
使用步骤:
1.创建一个FileReader对象
2.使用FileReader对象中的方法read读取文件
3.释放资源
代码示例:
public static void main(String[] args) throws IOException {
// 创建FileReader对象
FileReader fr = new FileReader("D:\\abc\\a\\java.txt");
/*
// 一次读取一个字符
int len = 0;
while ((len = fr.read()) != -1) {
System.out.print((char)len);
}
*/
// 一次读取多个字符
char[] c = new char[1024];
int len = 0;
while ((len = fr.read(c)) != -1) {
// 使用String的构造方法讲字符转换为字符串
// String(char[] value)
// 分配一个新的 String,使其表示字符数组参数中当前包含的字符序列。
// String(char[] value, int offset, int count)
// 分配一个新的 String,它包含取自字符数组参数一个子数组的字符。
System.out.println(new String(c, 0, len));
}
}
3.3 字符输出流 Writer
java.io.Writer:字符输出流,是所有字符输出流的最顶层的父类,是一个抽象类
3.3.1 共性的成员方法:
void write(int c):写入单个字符
void write(char[] cbuf):写入字符数组
abstract void write(char[] cbuf, int off, int len):写入字符数组的某一部分,off字符串的开始索引,len写的字符个数
void write(String str):写入字符串
void write(String str, int off, int len):写入字符串的某一部分,off字符串的开始索引,len写的字符个数
void flush():刷新该流的缓冲
void close():关闭流
3.4 文件字符输出流 FileWriter
java.io.FileWriter extends OutputStreamWriter extends Writer
作用:把内存中字符数据写入到文件中
构造方法:
FileWriter(FIle file):根据给定的File对象构造一个FileWriter对象
FileWriter(String fileName):根据给定的文件名构造一个FileWriter对象
参数:写入数据的目的地
String fileName:文件的路径
File file:文件对象
构造方法作用:
1.创建一个FileWriter对象
2.根据构造方法中传递的文件或者文件路径,创建一个文件
3.会把FileWriter对象指向创建好的文件
使用步骤:
1.创建FileWriter对象,构造方法中绑定写入数据的目的地
2.使用FileWriter中的方法write,把数据写入到内存缓冲区中(字符转换为字节的过程)
3.使用FileWriter中的方法flush,把内存缓冲区中的数据,刷新到文件中
4.释放资源(会先把内存缓冲区中的数据刷新到文件中,第三步可以省略)
代码示例:
public static void main(String[] args) throws IOException {
// 创建FileWriter对象并绑定写入数据的目的地
FileWriter fw = new FileWriter(new File("D:\\abc\\a\\b.txt"));
// 写入单个字符
// fw.write('你');
// 写入字符数组
// char[] c = {'你', '好', '!', '!'};
// fw.write(c);
// 写入字符数组的某一部分
// fw.write(c, 0, 3);
// 写入字符串
// fw.write("啥时候能学完呀");
// 写入字符串的某一部分
fw.write("啥时候能学完呀", 0, 3);
// 刷新该流的缓冲(close会先把缓冲区的数据刷新到文件中,这步可省略)
fw.flush();
// 关闭流
fw.close();
}
3.4.1 flush和close的区别
共同点:都可以把数据刷新到文件中
不同点:
flush刷新缓冲区后,流对象可以继续使用
close先刷新缓冲区,然后释放资源,流对象不可以再被使用
3.4.2 字符输出流续写和换行
追加写:
FileWriter(String fileName, boolean append)
创建一个向具有指定 fileName的文件中写入数据的输出文件流。
FileWriter(File file, boolean append)
创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
参数:
boolean append:true创建对象不会覆盖源文件,继续在文件末尾追加数据
false:创建一个新文件,覆盖源文件
换行写:
windows:\r\n
linux:/n
mac:/r
4、 try catch finally处理流的异常
jdk7之前用try catch finally处理流的异常:
代码示例:
public static void main(String[] args) {
// 提高fw的作用域,使finally可以使用
// 变量在定义的时候可以没有值,但是在使用的时候必须有值
// new FileWriter(new File("D:\\abc\\a\\b.txt"), true)如果执行失败,fw.close();会执行报错
FileWriter fw = null;
try {
// 创建FileWriter对象并绑定写入数据的目的地
fw = new FileWriter(new File("D:\\abc\\a\\b.txt"), true);
// 写入字符串
fw.write("啥时候能学完呀" + "\r\n");
} catch (IOException e) {
e.printStackTrace();
} finally {
// 刷新并且关闭流
// 如果创建对象失败了,fw的默认值是null,null是不能调用方法的,会抛出空指针异常,需要判断对象是否为null,不为null调用close方法
if (fw != null) {
try {
// fw.close申明抛出了IOException异常,必须处理
fw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
jdk7之后用try catch处理流的异常:
jdk7新特性
在try后可以增加(),括号中可以定义流对象,流对象的作用域在整个try中有效,try中的代码执行完毕,会自动释放流对象,不用再写finally
格式:
try(定义流对象; 定义流对象····) {
可能出现异常的代码
} catch (异常类 变量名){
异常的处理逻辑
}
代码示例:
public static void main(String[] args) {
try (// 创建FileWriter对象并绑定写入数据的目的地
FileWriter fw = new FileWriter(new File("D:\\abc\\a\\b.txt"));
// 创建FileReader对象并绑定要读取数据的目的地
FileReader fr = new FileReader("D:\\abc\\a\\b.txt")){
// 写入字符串
fw.write("啥时候能学完呀");
// 刷新缓冲区数据至文件
fw.flush();
// 一次读取多个字符
char[] c = new char[1024];
int len = 0;
while ((len = fr.read(c)) != -1) {
System.out.println(new String(c, 0, len));
}
} catch (IOException e) {
e.printStackTrace();
}
}
JDK9新特性:
try的前边可以定义流对象
在try后边的()中可以直接引入流对象的名称
在try代码执行完毕之后,流对象也可以释放掉,不用写finally
格式:
A a = new A();
B b = new B();
try (a; b) {
}catch(){}