IO概述
- java中I/O的操作主要是靠java.io包下面的类和接口来实现,进入输入、输出操作。输入也可以叫做读取数据,输出也可以叫做写入数据。
IO分类
根据数据的流向分为:输入流和输出流。 - 输入流:把数据从其他设备上读取到内存当中的流。
- 输出流:把数据从内存当中写入到其他设备上的流。
IO流的顶级父类
输入流 | 输出流 | |
---|---|---|
字节流 | 字节输入流InputStream | 子输出流OutputStream |
字符流 | 字符输入流Reader | 字符输出流Writer |
字节流
一切皆为字节
- 一切文件数据(文本文档,图片,视频等)在存储时,都是以二进制数字的形式保存的,都是一个一个的字节,那么数据在进行传输的时候也是如此。所以字节流可以传输任意文件的数据。在操作流的时候,我们要明确,无论使用了什么样的流对象,底层传输的始终为二进制数据。
字节输出流【outputStream】
java.io.OutputStream 此抽象类是表示输出字节流的所有类的超类,将指定的字节信息写入到目的地,他定义了字节输出流的基本共性的api方法:
- public void close():关闭输出流并释放与此相关的其他任何系统资源。
- public void flush():刷新此输出流并强制任何缓冲的输出字节信息被写入。
- public void write(byte[] b):将b.length字节从指定的字节数组写入到此输出流中。
- pubic void write(byte[] b ,int off,int len):从指定的字节数组写入len个字节,从偏移量off开始输出到此输出流中
- public abstract void write(int b);将指定的字节输出到此输出流中。
备注: colse方法,当完成流的操作时,必须调用此方法,释放系统资源。
FileoutputStream类
java.io.FileOutputStream类是文件字节输出流,用于将数据写入到文件中。
构造方法
- public fileOutputStream :创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
- FileOutputStream(String name) :创建一个向具有指定名称的文件中写入数据的输出文件流。
- 当你创建一个流对象时,必须传递一个文件路径,该路径下,如果没有这个文件,会创建该文件,如果有这个文件,会清空这个文件当中的数据。
示例代码:
// 1.创建一个FileOutputStream类对象,构造方法中传递写入数据的目的地。
FileOutputStream fos = new FileOutputStream("day28_IO\\a.txt");
// 2.调用FileOutputStream对象中的方法write,把数据写入到文件中
fos.write(97);
// 3.释放资源。
fos.close();
数据的追加续写
如何在保留目标文件的数据,还能继续添加新的数据到目标文件中?
- public FileOutputStream(File file,boolean append):创建文件输出流以写入由指定的File对象表示的文件中。
- public FileOutputStream(String name,boolean append):创建文件的输出流以指定的名称写入到文件中。
这两个构造文件,参数中都需要传入一个boolean类型的值,true表示追加数据,false表示的清空原有的数据。
在这样的情况下创建对象
代码演示如下:
//创建对象
FileOutputStream fos = new FileOutputStream("day28_IO\\c.txt", false);
//2调用write()
fos.write("HelloWorld".getBytes());
//关闭流
fos.close();
写入换行:
Windows系统里,换行符号是’\r\n’。把已指定是否需要追加续写换行。
Linux:系统中换行符号/n
mac系统里,换行符号是/r
Unix系统里,每行的结尾只有换行,即/n
回车符\r 和换行符\n
- 回车符号:回到一行的开头
- 换行符号:下一行(newLine)
系统中的换行:
-windows系统中,每行结尾回车+换行。即**\r\n**。 - Unix系统中,每行的结尾只有换行,即/n
- Mas系统中,每行的结尾是回车,即/r
代码示例如下:
//创建对象
FileOutputStream fos = new FileOutputStream("day28_IO\\c.txt", true);
//2调用write()
fos.write("HelloWorld".getBytes());
//实现数据换行
fos.write("\r\n".getBytes());
//关闭流
fos.close();
字节输入流【InputStream】
java.io.InputStream次抽象类是表示字节输入流的所有类的超类。可以读取字节信息到内存中。他定义了字节输入流的基本共性的api方法:
- public void close():关闭此输入流并释放与此流相关的其他的任何系统资源。
- public abstract int read():从输入流中读取数据的下一个字节
- public int read(byte[] b):从输入流中读取一些字节数,并将它们存储到字节数组b当中。
备注:colse方法,当完成流的相关操作后,需要调用此方法关闭输入流,释放系统资源。
FileInputStream类
java.io.FileInputStream类是文件输入流,从文件中读取字节。
构造方法 - FileInputStream(File file):通过打开与实际文件的连接来创建一个FileInputStream,该文件由文件系统中的File对象file命名。
- FileInputStream(String name):通过打开与实际文件的连接来创建一个FileInputStream,该文件由文件系统中的路径名name命名。
当你创建一个流对象时,必须传入一个文件路径。该路径下,如果没有该文件,会抛出FileNotFoundException。
代码示例:
// 1. 创建一个FileInputStream类对象,构造方法中绑定要读取的文件
FileInputStream fis = new FileInputStream("day28_IO\\c.txt");
// 2. 使用FileInputStream类对象中的方法read(),读取文件中的数据
int len = 0 ;// 表示记录读取到的字节
while ( (len = fis.read()) != -1) {
System.out.print((char)len+"");// Hello
}
// 3. 释放资源,关闭流对象。
fis.close();
- 可以使用字节数组来读取数据:read(byte[] b):从输入流中读取多个字节,并且将其存储到缓冲区数组b当中。当读取到文件的末尾时,返回一个
-1
。
代码演示如下:
//1.创建对象
FileInputStream fis = new FileInputStream("day28_IO\\c.txt");
int len = 0;// 记录读取到的有效字节个数
byte[] bytes = new byte[1024];// 2^10 1024b = 1kb
while ((len = fis.read(bytes)) != -1) {
// byte[] 转换成String
// String(byte[] bytes,int offset,int length) 把字节数组的一部分转换成字符串
//System.out.println(Arrays.toString(bytes));//[B@74a14482
System.out.println(new String(bytes,0,len));
}
- 备注:使用数组读取,每次可以读取多个字节,减少了系统间的IO操作次数,从而提高了读取的效率,建议使用。
- 练习:通过字节流实现图片复制 FileInputStream 和 FileOutputStream
- 实现从桌面的G1.jpeg图片复制到E:\documents\day28_IO目录下。
- 原理:从已知的文件中读取字节,再把读取到的字节写入到另一个文件中。
public static void main(String[] args) throws IOException {
// 构建开始时间
long start = System.currentTimeMillis();
// 1.创建一个字节输入流对象,构造方法中绑定需要读取的图片路径
FileInputStream fis = new FileInputStream("C:\\Users\\admin\\Desktop\\3.gif");
// 2.创建一个字节输出流对象,构造方法中绑定需要写入的文件
FileOutputStream fos = new FileOutputStream("E:\\documents\\day28_IO\\3.gif");
byte[] bytes = new byte[1024];
int len = 0;//记录读取到的有效字节个数
while ((len = fis.read(bytes)) != -1) {
//4.使用字节输出流对象中的write方法,把读取到字节写入到指定的文件中
fos.write(bytes,0,len);
}
// 5.释放资源。(先开的后关,后开的先关)
fos.close();
fis.close();
// 构建结束的时间
long end = System.currentTimeMillis();
System.out.println("复制文件耗费的时间为:" + (end - start) + "ms");
}
- 备注:流的关闭顺序:先开后关,后开先关。
字符流
- 当使用字节流读取文件文件的时候,可能会引发一点小问题。如果你遇到了中文字符时,可能不会显示完整的字符。那就是因为一个中文字符可能占用多个字节存储。所以Java提供了一些字符流类,以字符为单位读写数据,专门用于处理文本文档文件。
字符输入流【Reader】 java.io.Reader
抽象类是表示用于读取字符流的所有类的超类,可以读取字符信息到内存当中,它定义了字符输入流的基本共性的api方法:- public void close():关闭此输入流并且释放与此流相关的其他系统资源。
- public int read():从输入流中读取一个字符。
- public int read(char[] chuf):从输入流中一次读取多个字符,并将它们存储到字符数组chuf当中。
FileReader类
java.io.FileReader类主要用于读取字符文件的便捷类。构造方法使用默认的编码字符集和默认的字节缓冲区。
备注:- 字符编码:字节与字符的对应规则。Windows系统中的中文编码默认是GBK编码表,idea中采用UTF-8
2. 字节缓冲区:一个字节数组,用来临时存储字节数据。
构造方法:
- 字符编码:字节与字符的对应规则。Windows系统中的中文编码默认是GBK编码表,idea中采用UTF-8
- FileReader(File file):创建一个新的FIleReader对象,指定需要读取的file对象。
- FileReader(String filename):创建一个新的FileReader对象,指定需要读取的文件名称。
- 当你创建一个流对象时,必须传入一个文件路径。类似于FileInputStream。
代码示例
// 1.创建对象,构造方法中绑定需要读取的文件数据源
FileReader fr = new FileReader("day28_IO\\c.txt");
// 2.使用该对象中的方法read()来读取文件数据
// int read() 读取单个字符并返回
/*int len = fr.read();
System.out.println((char)len);// 72 H 张*/
int len = 0;// 记录读取的字符
while ((len = fr.read()) != -1) {
System.out.print((char)len);
}
- 使用字符数组读取数据:read(char[] chuf),每次读取chuf的长度个字符到数组当中,返回读取到有效字符的个数。当它读取到末尾时,返回
-1
。
代码示例:
// 1.创建对象,构造方法中绑定需要读取的文件数据源
FileReader fr = new FileReader("day28_IO\\c.txt");
char[] chuf = new char[1024];
int len = 0;// 记录的是每次读取的有效的字符个数
//2. 使用该对象中的方法read()来读取文件数据
while ((len = fr.read(chuf)) != -1) {
// 字符数组转换成字符串
System.out.println(new String(chuf,0,len));
}
// 3.释放资源,关闭此输入流。
fr.close();
字符输出流【Writer】
java.io.Writer
抽象类是表示用于输出字符流的所有类的超类。将指定的字符信息写入到目的地中。它定义了字符输出流的基本共性的api方法:
- void write(int c):写入单个字符。
- void write(char[] chuf):写入字符数组。
- abstract void write(char[] chuf,int off,int len):写入char数组的一部分,从char数组的起始索引值off开始,len个写入字符个数。
- void write(String str):写入字符串。
- void write(String str,int off,in len):写入字符串的一部分,从字符串的起始索引off开始,写入len个字符个数。
- void flush():刷新该流的缓冲。
- void close():关闭此流,但是需要先刷新它。
FileWriter类 java.io.FileWriter
类是用于写入字符到文件中。构造方法使用系统默认的字符编码和默认的字节缓冲区。
构造方法- FileWriter(File file):创建一个新的FileWriter,指定写入的file对象。
- FileWriter(String filename):创建一个新的FileWriter,指定需要写入的文件的名称。
当你创建一个流对象时,必须传入一个文件路径,类似于FileOutputStream。
代码示例:
public static void main(String[] args) throws IOException {
// 1.创建一个FileWriter对象,构造方法中绑定需要写入数据的目的地。
FileWriter fw = new FileWriter("day28_IO\\e.txt");
// 2.使用fileWriter对象中的方法write,把数据写入到内存缓冲区中(字符转换为字节的过程)
// void write(int c) 写入单个字符
fw.write(122);// K z
// 3.使用FileWriter对象的中的方法flush,把内存缓冲区中的数据刷新到文件中。
//fw.flush();
// 4.释放资源(会先把内存缓冲区中的数据刷新到文件中)
fw.close();
}
关闭和刷新
- 因为内置缓冲区的原因,如果不关闭输出流,无法写入字符到文件中。但是关闭流对象,是无法继续写入数据到文件中。如果既想写入数据到文件中,又想继续使用流对象,那么就需要flush方法。
- flush:刷新缓冲区,流对象可以继续使用
- close:先刷新缓冲区,然后会通知系统释放资源,关闭流对象,流对象不可以再使用。
代码示例:
public static void main(String[] args) throws IOException {
// 1.创建对象
FileWriter fw = new FileWriter("day28_IO\\e.txt");
// 2.调用write方法
fw.write(97);// a
// 3. 刷新
fw.flush();
// 刷新之后流可以继续使用
fw.write(98);
// 4. 关闭流对象
fw.close();
// close方法之后,流已经关闭了,已经从内存当中消失了,流不能再使用了,如果使用抛出Stream closed
fw.write(99);
}
写入字符数组:write(char[] chuf)
和write(char[] chuf,int off,int len)
,每次可以写入一个字符数组的数据,用法类似于FileOutputStream。
代码示例如下:
//1. new
FileWriter fw = new FileWriter("day28_IO\\f.txt");
//2. write
//2.1 char[]
char[] chars = new char[]{'a','b','c','d','e','f'};
fw.write(chars);// abcdef
//abstract void write(char[] chuf,int off,in len):写入字符数组的一部分,从off起始索引开始,写入len个字符个数
fw.write(chars, 3, 3);// def
//void write(String str):写入一个字符串
fw.write("你好,Java");
//void write(String str,int off,int len):写入字符串的一部分,从off起始索引开始,写入len个字符个数
fw.write("你好,Java",3,4);// Java
//3. flush
//fw.flush();
//4. 关闭
fw.close();
续写和换行:操作类似于FileOutputStream
public static void main(String[] args) throws IOException {
// 1. new
FileWriter fw = new FileWriter("day28_IO\\g.txt", true);
//2. write
char[] chars = new char[50];
//fw.write();
for (int i = 0; i < 50; i++) {
chars[i] = (char) (20000+i);
fw.write(chars[i] + "\r\n");//换行性质
}
//3. 刷新
fw.flush();
//4. 关闭
fw.close();
}
有些地方可能做的不是很好,请见谅谢谢。。。。。。。。。。