IO 操作大结局
之前三篇文章分别讲解了 File 类,操作 IO 的套路,不能不懂的处理流。
今天的文章是 Java IO 的大结局,我们来聊聊 IO 的其它几个有用的流,内存流,打印流、压缩流。
一、内存操作流
前面讲解的输入和输出都是操作文件的,其实我们也可以将内容写到内存,以及从内存中读取数据。内存操作流也就是字节数组节点流,分为字节数组输入流和字节数组输出流。我们可以使用字节数组输入流 BufferedInputStream 类读取内存中的数据,使用字节数组输出流 ByteArrayOutputStream 类将内容写到内存。
内存操作流一般用于生成临时信息,数据内容比较少的场景下,如果临时信息用文件保存的话,代码执行完毕后需要删除这个临时文件,所以这种有临时信息的存储使用内存操作是最合适的。
下面通过一段代码来演示内存操作流的使用:
@Test
public void test() throws IOException {
read(write());
}
/**
* 字节数组输入流的操作与文件输入操作流的操作一样
*/
public void read(byte[] src) throws IOException {
// 数据源是传入的
// 字节数组输入流,可以读取其他电脑上内存的内容
InputStream is = new BufferedInputStream(new ByteArrayInputStream(src));
// 操作
byte[] b = new byte[1024];
int len = 0;
while ((len = is.read(b)) != -1) {
System.out.println(new String(b, 0, len));
}
is.close();
}
/**
* 字节数组输出流的操作与文件输出操作流的操作有区别,因为字节数组输出流有新增的方法,不能使用多态
*/
public byte[] write() throws IOException {
byte[] dest; // 输出的目的地
// 选择流,没有入参,不用把dest传入
ByteArrayOutputStream bos = new ByteArrayOutputStream();
// 写出
String msg = "字节数组输入流的操作与文件输入操作流的操作一样";
byte[] src = msg.getBytes();
bos.write(src, 0, src.length);
bos.flush();
// 字节数组输出流是通过toByteArray方法获取的数据,因此不需要在构造函数传入dest参数
dest = bos.toByteArray();
bos.close();
return dest;
}
运行结果:
字节数组输入流的操作与文件输入操作流的操作一样
二、打印流
1、认识打印流
打印流是输出信息最方便的流,主要使用字节打印流 PrintStream,PrintStream 类继承 FilterOutputStream 类,FilterOutputStream 类继承 OutputStream 类。在 PrintStream 类的对象创建的时候可以把 OutputStream 类的对象传入,也就是说 PrintStream 类包装了 OutputStream 类或者 FilterOutputStream 类,这也就是我们经常说的的装饰设计模式,用装饰设计模式包装后,使操作更加方便。
代码示例:
@Test
public void test() throws IOException {
System.out.println("打印流");
// System.out本身就是PrintStream的实例,所以可以直接赋值
PrintStream ps = System.out;
ps.println(100); // 默认输出到控制台
// 用PrintStream输出到文件
File file = new File("D:/file/txt/print.txt");
ps = new PrintStream(new BufferedOutputStream(new FileOutputStream(file)));
ps.println("print io test ...");
ps.flush();
ps.close();
}
运行结果:
打印流
100
2、了解 System 类的三个常量以及 Scanner 类
1、System.in:输入流,表示键盘输入
2、System.out:输出流,表示控制台输出
3、System.err:异常,输出的字体是红色的
另外我们可以使用 Java 提供的 Scanner 类进行数据输入,比如我们通过控制台接收用户的输入,完成输出。Scanner 类提供了一个可以接收 InputStream 类型的构造方法,这就说明只要是字节输入流的子类都可以通过 Scanner 类进行方便的读取,这也是装饰设计模式,需要注意的是:在 Java IO 中使用了大量的装饰模式。
代码演示,包括如何使用可变参数实现资源关闭:
@Test
public void test1() throws IOException {
// System的三个常量:
System.out.println("test");
System.err.println("error"); // 输出的字体是红色的
InputStream is = System.in; // 键盘输入
Scanner scanner = new Scanner(is);
System.out.println("Scanner 请输入:");
System.out.println(scanner.nextLine());
// 封装字节输入流似Scanner
BufferedReader br = new BufferedReader(new InputStreamReader(is)); // 字节流转字符流
System.out.println("封装字节输入流似Scanner 请输入:");
System.out.println(br.readLine());
// 键盘输入改为文件输入
InputStream is1 = new BufferedInputStream(new FileInputStream(new File("D:/file/txt/print.txt")));
Scanner scanner1 = new Scanner(is1);
System.out.println(scanner1.nextLine());
close(scanner1, is1, scanner, is);
}
/**
* 关闭资源,用可变参数实现,可变参数:用三个点表示,只能放在形参的最后一个位置
*/
public static void close(Closeable... io) {
if (io != null) {
for (Closeable closeable : io) {
try {
if (closeable != null) {
closeable.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
运行结果:
test
error
Scanner 请输入:
可多看点
可多看点
封装字节输入流似Scanner 请输入:
你好
你好
print io test ...
三、压缩流
者多个文件进行压缩,以方便传输。在 Java 中为了减少传输过程的数据量提供了专门的压缩流,可以将文件或者文件夹压缩成 ZIP、JAR、GZIP等格式。
1、ZIP 文件压缩
压缩文件需要用到压缩输出流 ZipOutputStream 类,每一个被压缩的文件都用一个 ZipEntry 对象表示,用 putNextEntry() 方法可以把 ZipEntry 对象加入到压缩输出流里面,之后调用 closeEntry() 方法关闭当前 ZipEntry 对象。
用一个例子演示单个文件的压缩:
@Test
public void test() throws IOException {
// 指定要压缩的文件夹
File srcFile = new File("D:/file/txt/print.txt");
// 指定压缩后的文件
File zipFile = new File("D:/file/txt/print.zip");
// 定义输入文件流
InputStream is = new BufferedInputStream(new FileInputStream(srcFile));
// 定义压缩输出流
OutputStream out = new BufferedOutputStream(new FileOutputStream(zipFile));
ZipOutputStream zipOut = new ZipOutputStream(out);
// 压缩文件的每一个子文件都是一个ZipEntry,需要为ZipEntry设置名称
System.out.println(srcFile.getName());
ZipEntry entry = new ZipEntry(srcFile.getName());
// 设置entry对象
zipOut.putNextEntry(entry);
// 关闭当前entry对象
zipOut.closeEntry();
// 压缩操作
byte[] b = new byte[1024];
int len = 0;
while ((len = is.read(b)) != -1) {
zipOut.write(b, 0, len); // 压缩内容
}
zipOut.flush();
zipOut.close();
is.close();
}
下面是一个压缩文件夹的例子,就是在利用上面的代码加上文件夹的列出文件方法结合递归实现的。
@Test
public void test1() throws Exception {
// 指定要压缩的文件夹
File srcFile = new File("D:/file/txt");
// 指定压缩后的文件
File zipFile = new File("D:/file/txt.zip");
// 定义压缩输出流
OutputStream out = new BufferedOutputStream(new FileOutputStream(zipFile));
ZipOutputStream zipOut = new ZipOutputStream(out);
// 压缩文件夹
zipFile(zipOut, srcFile, srcFile.getName());
zipOut.flush();
zipOut.close();
}
/**
* @Description: 递归压缩文件夹
* @param zipOut 压缩输出流,必须在外部关闭
* @param src 要压缩的目标文件夹
* @param zipPath 压缩后的目标文件路径
*/
public void zipFile(ZipOutputStream zipOut, File src, String zipPath) throws FileNotFoundException, IOException {
if (src.isDirectory()) {
File[] files = src.listFiles();
if (files != null && files.length > 0) {
for (File file : files) {
// 压缩包中如果要保留原来的文件结构,必须带上父文件夹的名字加一斜杠,否则所有文件都写到压缩包目录下了
zipFile(zipOut, file, zipPath + "/" + file.getName());
}
} else { // 对空文件夹也进行压缩
zipOut.putNextEntry(new ZipEntry(zipPath + "/"));
zipOut.closeEntry();
}
} else {
InputStream is = new BufferedInputStream(new FileInputStream(src));
zipOut.putNextEntry(new ZipEntry(zipPath));
byte[] b = new byte[1024];
int len = 0;
while ((len = is.read(b)) != -1) {
zipOut.write(b, 0, len);
}
zipOut.closeEntry();
is.close();
}
}
运行结果:
2、ZIP 文件解压
在 Java 中每一个压缩文件都可以用 ZipFile 表示,还可以 使用 ZipFile 根据压缩后的文件名称找到每一个压缩文件中的 ZipEntry 对象,并将其进行解压操作。
下面我们分部对上面压缩的2个文件进行解压,首先对单个文件解压:
@Test
public void test2() throws ZipException, IOException {
// 找到压缩文件
File srcFile = new File("D:/file/txt/print.zip");
// 定义解压缩的文件名称
File destFile = new File("D:/file/txt/print_unzip.txt");
// 创建ZipFile对象
ZipFile zipFile = new ZipFile(srcFile);
// 根据压缩文件里的名称获取ZipEntry对象,名称必须能找到,否则获取输入流时空指针异常
ZipEntry entry = zipFile.getEntry("print.txt");
if (entry != null) {
// 根据ZipEntry对象获取ZipEntry输入流
InputStream is = zipFile.getInputStream(entry);
// 创建输出流
OutputStream os = new BufferedOutputStream(new FileOutputStream(destFile));
// 读取并输出
byte[] b = new byte[1024];
int len = 0;
while ((len = is.read(b)) != -1) {
os.write(b, 0, len);
}
os.flush();
os.close();
is.close();
}
zipFile.close();
}
运行结果:
以上程序如果一个压缩文件中存在多个文件夹或者多个 ZipEntry 就不行了,要操作更复杂的压缩文件需要用到 ZipInputStream 类实现。ZipInputStream 类可以方便的读取 ZIP 格式的压缩文件,下面我们演示解压复杂压缩文件的代码:
@Test
public void testUnZip() throws IOException {
// 指定要解压缩的文件夹
File srcFile = new File("D:/file/txt.zip");
// 指定解压缩后的目录
String destPath = "D:/file/txt_unzip/";
unZipFile(srcFile, destPath);
}
/**
* @Description: 文件夹解压方法
* @param srcFile 要解压缩的文件夹
* @param destPath 指定解压缩后的目录
*/
public void unZipFile(File srcFile, String destPath) throws FileNotFoundException, IOException {
// 创建zip输入流
ZipInputStream zis = new ZipInputStream(new BufferedInputStream(new FileInputStream(srcFile)));
ZipEntry entry = null;
OutputStream os = null;
// 指定解压缩后的文件
File destFile = null;
while ((entry = zis.getNextEntry()) != null) {
destFile = new File(destPath + entry.getName());
// entry有两种情况,要么是文件夹,要么是文件
if (entry.isDirectory()) { // 如果是文件夹,可以先创建,这样空文件夹也能解压缩
destFile.mkdirs();
} else {
if (!destFile.getParentFile().exists()) { // 创建文件的父目录,否则找不到路径
destFile.getParentFile().mkdirs();
}
os = new BufferedOutputStream(new FileOutputStream(destFile));
byte[] b = new byte[1024];
int len = 0;
while ((len = zis.read(b)) != -1) {
os.write(b, 0, len);
}
os.flush();
os.close();
}
}
zis.close();
}
以上的压缩与解压缩的代码,大家可以用到自己的项目中。
3、其他格式的压缩输入输出流
ZIP 是一种常见的压缩方式,在Java 开发过程中也可以实现 JAR 和 GZIP 格式的压缩与解压操作。
JAR 压缩的支持类在 java.util.jar 包中,常用类如下:
JAR 压缩输入流:JarInputStream
JAR 压缩输出流:JarOutputStream
JAR 文件:JARFile
JAR 实体:JAREntry
GZIP 是用于 Linux 系统的文件压缩,在 Linux 中经常会使用到*.gz 的文件,就是 GZIP 格式,GZIP 压缩的支持类在 java.util.zip 包中,常用类如下:
JAR 压缩输入流:GZIPInputStream
JAR 压缩输出流:GZIPOutputStream
大家可以自己仿照 ZIP 压缩解压的代码,试着操作一下。
**在文章的最后用一张图来总结一下 Java IO 的重点流,大家掌握了字节流和缓存流就足够使用了,IO 操作是有套路的,通过 Java IO 四篇文章的学习,相信 IO 操作对你来说已经不是问题了。