Java I/O操作
Java I/O的内容比较多, 类库里提供了各种各样的流. 很多使用起来类似, 这里只列举了几种常用的I/O流操作.
1. I/O简介
I/O就是输入和输出，核心是I/O流，流用于读写设备上的数据，包括硬盘文件、内存、键盘、网络...
- 根据数据的走向分为：输入流、输出流
- 根据处理的数据类型分为：字节流、字符流
字节流能处理所有类型数据，对应的类以Stream结尾。
字符流只能处理文本数据，对应的类以Reader或Writer结尾。
- 根据功能不同可分为：节点流、处理流
io流.png
(图中橙色部分是节点流, 蓝色是处理流, 处理流需要封装节点流使用)
各种流的继承关系:
Java-IO.png
2. 使用字节流读写数据
- 使用字节流读数据：
import java.io.FileInputStream;
import java.io.IOException;
public class ReadByteStream {
public static void main(String[] args) {
FileInputStream fis = null; // 声明文件输入流对象
try {
fis = new FileInputStream("test.txt"); // test.txt文件在当前工程目录下事先创建好
byte input[] = new byte[30];
fis.read(input); // 读入到一个字节数组
String str = new String(input, "UTF-8"); // 字符编码要与读入的文件对应
System.out.println(str);
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
fis.close(); // 关闭输入流
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
- 使用字节流写数据：
import java.io.FileOutputStream;
import java.io.IOException;
public class WriteByteStream {
public static void main(String[] args) {
FileOutputStream fos = null;
try {
fos = new FileOutputStream("test2.txt");
String str = "1234567";
byte[] outStr = str.getBytes("UTF-8"); // 读入字节数组，并指定编码方式
fos.write(outStr); // 使用文件输出流写出到文件
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
- 使用字节流拷贝文件
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class CopyFile {
public static void main(String[] args) {
FileInputStream fis = null;
FileOutputStream fos = null;
try {
fis = new FileInputStream("test.png");
fos = new FileOutputStream("test_new.png");
byte input[] = new byte[50]; // 每次读取50 bytes
while (fis.read(input) != -1) { // read返回读入的数据大小，如果没有数据返回-1
fos.write(input); // 每次写入50 bytes
}
System.out.println("done");
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
fis.close();
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
3. 使用带缓冲的字节流读写数据
带缓冲的流和不带缓冲的流区别:
- 不带缓冲的操作, 每读一个字节就要写入一个字节, 由于涉及磁盘的IO操作相比内存的操作要慢很多, 所以不带缓冲的流效率很低
- 带缓冲的流, 可以一次读很多字节, 但不向磁盘中写入, 只是先放到内存里. 等凑够了缓冲区大小的时候一次性写入磁盘, 这种方式可以减少磁盘操作次数, 速度就会提高很多!
- 带缓冲的流适合读写比较大的文件.
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class ReadByBufferedByteStream {
public static void main(String[] args) {
try {
FileInputStream fis = new FileInputStream("movie.mp4");
BufferedInputStream bis = new BufferedInputStream(fis,1000000); // 缓冲区大小1000000字节
FileOutputStream fos = new FileOutputStream("moive_new.mp4");
BufferedOutputStream bos = new BufferedOutputStream(fos,1000000); // 缓冲区大小1000000字节
//大型文件对应的数组可以大一些，小文件对应的数组小一些
byte input[] = new byte[100000]; // 每次读写字节大写
int count = 0;
long before = System.currentTimeMillis(); // 开始计时
while (bis.read(input) != -1) {
bos.write(input);
count++;
}
bos.flush();
bis.close();
fis.close();
bos.close();
fos.close();
System.out.println(System.currentTimeMillis()-before+"ms"); // 总时长
System.out.println("读取了："+count+"次");
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
4. 使用字符流读写数据
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
public class RWByCharStream {
public static void main(String[] args) {
try {
FileInputStream fis = new FileInputStream("java.txt");
FileOutputStream fos = new FileOutputStream("java_new.txt");
InputStreamReader reader = new InputStreamReader(fis, "UTF-8"); // 字符流的使用要传入字节流作为参数
OutputStreamWriter writer = new OutputStreamWriter(fos, "UTF-8");
char input[] = new char[100]; // 每次读取的数据大小
int l = 0;
while ((l = reader.read(input)) != -1) {
// void write(char cbuf[], int off, int len)
// 文件末尾的长度不一定是100，所以需要设置写入数据长度
writer.write(input, 0, l);
}
reader.close(); // 先关闭字符流
fis.close(); // 再关闭字节流
writer.close();
fos.close();
System.out.println("done");
} catch (IOException e) {
e.printStackTrace();
}
}
}
5. 使用带缓冲的字符流读写数据
使用字符流读取数据时不能按行读取，这时候就需要使用带有缓冲区的字符流。
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.Writer;
public class RWByBufferedCharStream {
public static void main(String[] args) {
try {
FileInputStream fis = new FileInputStream("java.txt");
FileOutputStream fos = new FileOutputStream("java_new_buff.txt");
InputStreamReader reader = new InputStreamReader(fis, "UTF-8");
OutputStreamWriter writer = new OutputStreamWriter(fos, "UTF-8");
BufferedReader br = new BufferedReader(reader);
// BufferedWriter bw = new BufferedWriter(writer);
// PrintWriter和BufferedWriter用法类似
// PrintWriter可以输出换行符
// 构造方法PrintWriter(Writer out,boolean autoFlush) 里可以设置缓冲区自动输出，这样就不需要手动调用flush方法了。
PrintWriter pw = new PrintWriter(writer, true);
String input;
while ((input = br.readLine()) != null) { // BufferedReader可以按行读取
// bw.write(input); //
// BufferedWriter的writer方法是带有缓冲区的，此时打印的文本是不带换行符的
pw.println(input);// PrintWriter的println方法支持不同平台的换行符输出
}
// bw.flush(); // 强制输出缓冲区内容。如果不加上flush，最后的缓冲区未读满将不输出内容
// bw.close();
pw.close();// 按顺序关闭流
writer.close();
fos.close();
br.close();
reader.close();
fis.close();
System.out.println("done");
} catch (IOException e) {
e.printStackTrace();
}
}
}
6. FileReader 和FileWriter
FileReader 和FileWriter 专门用于操作文本文件. 用法与FileInputStream 类似.
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class FileRW {
public static void main(String[] args) {
FileReader fr = null;
BufferedReader br = null;
FileWriter fw = null;
BufferedWriter bw = null;
try {
fr = new FileReader("java.txt");
br = new BufferedReader(fr);
fw = new FileWriter("java_new.txt");
bw = new BufferedWriter(fw);
String line;
while ((line = br.readLine()) != null) {
bw.write(line + "\n");
}
bw.flush();
System.out.println("done");
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
bw.close();
fw.close();
br.close();
fr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
