Java——18个Demo带你玩转Java中的I/O流
Posted 张起灵-小哥
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java——18个Demo带你玩转Java中的I/O流相关的知识，希望对你有一定的参考价值。
文章目录：
5.Demo 5（FileInputStream & FileOutputStream完成文件的拷贝）
8.Demo 8（FileReader & FileWriter 完成对文件的拷贝）
15.Demo 15（I/O流联合Properties属性类使用）
18.Demo 18（ObjectInputStream & ObjectOutputStream）
写在前面
java.io包下需要掌握的流有16个：
文件专属：
java.io.FileInputStream
java.io.FileOutputStream
java.io.FileReader
java.io.FileWriter转换流：（将字节流转换成字符流）
java.io.InputStreamReader
java.io.OutputStreamWriter缓冲流专属：
java.io.BufferedReader
java.io.BufferedWriter
java.io.BufferedInputStream
java.io.BufferedOutputStream数据流专属：
java.io.DataInputStream
java.io.DataOutputStream标准输出流：
java.io.PrintWriter
java.io.PrintStream对象专属流：
java.io.ObjectInputStream
java.io.ObjectOutputStream这篇文章非常非常的长！！！因为我总结了Java中I/O常用的流的相关读写操作，希望我写的有一点点用吧！！！😄😄😄
1.Demo 1（FileInputStream）
package com.szh.io;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
/**
* java.io.FileInputStream
* 1) 文件字节输入流、万能的、任何类型的文件都可以采用这个流来读
* 2) 字节的方式，完成输入（读）的操作（磁盘 ---> 内存）
* public int read() throws IOException
* 该方法缺点：一次读取一个字节byte，这样内存和硬盘交互太频繁，时间都耗费在交互上面了
*/
public class FileInputStreamTest01 {
public static void main(String[] args) {
FileInputStream fis=null;
try {
//创建文件字节输入流对象
fis=new FileInputStream("F:/temp.txt");
//开始读
int readData=0;
while ((readData = fis.read()) != -1) {
System.out.println(readData);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
//在finally语句块中确保流一定关闭
if (fis != null) {
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
2.Demo 2（FileInputStream）
package com.szh.io;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
/**
* public int read(byte[] b) throws IOException
* 该方法一次最多读取 b.length 个字节
* 减少内存和硬盘之间的交互，提高程序的执行效率
*/
public class FileInputStreamTest02 {
public static void main(String[] args) {
FileInputStream fis=null;
try {
//创建文件字节输入流对象
fis=new FileInputStream("F:/temp.txt");
//开始读，采用byte数组
byte[] bytes=new byte[4];
int readCount=0;
while ((readCount = fis.read(bytes)) != -1) {
System.out.print(new String(bytes,0,readCount));
}
}catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fis != null) {
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
3.Demo 3（FileInputStream）
package com.szh.io;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
/**
* public int available() throws IOException
* 返回此输入流中可以读取（或跳过）的剩余字节数量
*
* public long skip(long n) throws IOException
* 跳过输入流中的n个字节的数据不读
*/
public class FileInputStreamTest03 {
public static void main(String[] args) {
FileInputStream fis=null;
try {
//创建文件字节输入流对象
fis=new FileInputStream("F:/temp.txt");
//available()方法 获取该文件中的总字节数量(此时还未读文件，所以数量为全部字节数)，存入byte数组中
//该方式不是读大文件，因为byte数组不能太大
byte[] bytes=new byte[fis.available()];
System.out.println("读之前文件中还可以读取的字节数量: " + fis.available());
int readCount=fis.read(bytes);
System.out.println(new String(bytes));
System.out.println("读之后文件中还可以读取的字节数量: " + fis.available());
//skip(long n)方法 跳过几个字节不读
// fis.skip(3);
// System.out.println(fis.read());
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fis != null) {
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
4.Demo 4（FileOutputStream）
package com.szh.io;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* java.io.FileOuputStream
* 1) 文件字节输出流，负责写
* 2) 从内存 ---> 硬盘
*/
public class FileOutputStreamTest01 {
public static void main(String[] args) {
FileOutputStream fos=null;
try {
//创建文件字节输出流对象，文件不存在时会自动新建
//该方法会先将原文件清空，然后重新写入，谨慎使用！！！
//fos=new FileOutputStream("F:/myfile.txt");
//下面这种方法在文件末尾追加写入，不会清空原文件内容
fos=new FileOutputStream("F:/myfile.txt",true);
//开始写
byte[] bytes={97,98,99,100};
fos.write(bytes);
//写完之后，最后一定记得刷新
fos.flush();
}catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fos != null) {
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
5.Demo 5（FileInputStream & FileOutputStream完成文件的拷贝）
package com.szh.io;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* 使用 FileInputStream 和 FileOutputStream 完成对文件的复制
*/
public class CopyTest01 {
public static void main(String[] args) {
FileInputStream fis=null;
FileOutputStream fos=null;
try {
//创建一个文件输入流对象
fis=new FileInputStream("F:/myfile.txt");
//创建一个文件输出流对象
fos=new FileOutputStream("E:/myfile.txt");
//核心：一边读，一边写
byte[] bytes=new byte[1024]; //1024B=1KB (一次最多读1KB)
int readCount=0;
while ((readCount = fis.read(bytes)) != -1) {
fos.write(bytes,0,readCount);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fis == null) {
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (fos == null) {
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
6.Demo 6（FileReader）
package com.szh.io;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
/**
* java.io.FileReader
* 文件字符输入流，只能读取普通文本
* 读取普通文本时，比较方便快捷
* 能用记事本编辑的都是普通文本文件
*/
public class FileReaderTest {
public static void main(String[] args) {
FileReader reader=null;
try {
//创建文件字符输入流对象
reader=new FileReader("F:/temp.txt");
//开始读，字节对应的是byte数组，字符对应的是char数组
char[] chars=new char[4]; //一次读取4个字符
int readCount=0;
while ((readCount = reader.read(chars)) != -1) {
System.out.print(new String(chars,0,readCount));
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (reader != null) {
try {
reader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
7.Demo 7（FileWriter）
package com.szh.io;
import java.io.FileWriter;
import java.io.IOException;
/**
* java.io.FileWriter
* 文件字符输出流，负责写
* 只能输出普通文本
* 能用记事本编辑的都是普通文本文件
*/
public class FileWriterTest {
public static void main(String[] args) {
FileWriter writer=null;
try {
//创建文件字符输出流对象
writer=new FileWriter("F:/temp.txt");
//开始写
char[] chars={'我','是','中','国','人'};
writer.write(chars);
writer.write(chars,2,3);
writer.write("Java");
//刷新
writer.flush();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (writer != null) {
try {
writer.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
8.Demo 8（FileReader & FileWriter 完成对文件的拷贝）
package com.szh.io;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
/**
* 使用 FileReader 和 FileWriter 完成对文件的复制，只能拷贝普通文本文件
* 能用记事本编辑的都是普通文本文件
*/
public class CopyTest02 {
public static void main(String[] args) {
FileReader reader=null;
FileWriter writer=null;
try {
//读
reader=new FileReader("F:/temp.txt");
//写
writer=new FileWriter("E:/temp.txt");
//一边读一边写
char[] chars=new char[512]; //一次读取512字节(0.5KB)
int readCount=0;
while ((readCount = reader.read(chars)) != -1) {
writer.write(chars,0,readCount);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (reader != null) {
try {
reader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (writer != null) {
try {
writer.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
9.Demo 9（BufferedReader）
package com.szh.io;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
/**
* java.io.BufferedReader
* 带有缓冲区的字符输入流
* 使用带缓冲区的流的时候不需要自定义byte数组、char数组
*/
public class BufferedReaderTest01 {
public static void main(String[] args) {
BufferedReader br=null;
try {
//当一个流的构造方法中需要另一个流的时候，内部被传进来的流叫做 节点流
//外部负责包装的流叫做 包装流
//也就是说此时，FileReader是节点流，BufferedReader是包装流
br=new BufferedReader(new FileReader("F:/Test.java"));
//循环读，一次读一行
String s=null;
while ((s = br.readLine()) != null) {
System.out.println(s);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
//关闭的时候只需要关闭包装流即可，而里面的节点流会自动关闭（详情见源代码）
if (br != null) {
try {
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
10.Demo 10（BufferedReader）
package com.szh.io;
import java.io.*;
/**
*
*/
public class BufferedReaderTest02 {
public static void main(String[] args) throws IOException {
//最内部是 一个文件字节 输入流
//中间的是 一个字节流转字符流 的输入流
//最外部是 一个缓冲字符 输入流 （也就是实现了字节流 ---> 字符流）
BufferedReader br=new BufferedReader(new InputStreamReader(new FileInputStream("F:/Test.java")));
//开始读
String line=null;
while ((line = br.readLine()) != null) {
System.out.println(line);
}
//只需关闭最外部的包装流即可
br.close();
}
}
11.Demo 11（BufferedWriter）
package com.szh.io;
import java.io.*;
/**
*
*/
public class BufferedWriterTest01 {
public static void main(String[] args) throws IOException {
//创建一个缓冲字符输出流
//BufferedWriter bw=new BufferedWriter(new FileWriter("E:/a.txt"));
BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(new FileOutputStream("E:/a.txt",true)));
//开始写
bw.write("Hello World!!!");
bw.write("\\n");
bw.write("Java I/O流");
bw.write("\\n");
//刷新
bw.flush();
//关闭最外部的包装流
bw.close();
}
}
12.Demo 12（DataOuputStream）
package com.szh.io;
import java.io.DataOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* java.io.DataOutputStream 数据专属的字节输出流
* 这个流可以将数据连同数据的类型一并写入文件（该文件不是普通的文本文件，无法用记事本打开）
*/
public class DataOutputStreamTest {
public static void main(String[] args) throws IOException {
//创建数据专属的字节输出流
DataOutputStream dos=new DataOutputStream(new FileOutputStream("E:/data"));
//写数据
byte b=100;
short s=200;
int i=300;
long j=400;
float f=0.5F;
double d=3.14;
boolean flag=false;
char a='我';
dos.writeByte(b);
dos.writeShort(s);
dos.writeInt(i);
dos.writeLong(j);
dos.writeFloat(f);
dos.writeDouble(d);
dos.writeBoolean(flag);
dos.writeChar(a);
//刷新
dos.flush();
//关闭
dos.close();
}
}
13.Demo 13（DataInputStream）
package com.szh.io;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
/**
* java.io.DataInputStream 数据专属的字节输入流
* DataOutputStream 写的文件只能使用 DataInputStream 来读，同时读的顺序必须和写的顺序一样
*/
public class DataInputStreamTest {
public static void main(String[] args) throws IOException {
//创建数据专属的字节输入流
DataInputStream dis=new DataInputStream(new FileInputStream("E:/data"));
//开始读
byte b=dis.readByte();
short s=dis.readShort();
int i=dis.readInt();
long j=dis.readLong();
float f=dis.readFloat();
double d=dis.readDouble();
boolean flag=dis.readBoolean();
char a=dis.readChar();
System.out.println(b);
System.out.println(s);
System.out.println(i);
System.out.println(j);
System.out.println(f);
System.out.println(d);
System.out.println(flag);
System.out.println(a);
//关闭
dis.close();
}
}
14.Demo 14（PrintStream）
package com.szh.io;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;
/**
* java.io.PrintStream
* 标准字节输出流，默认直接输出到控制台
*/
public class PrintStreamTest {
public static void main(String[] args) throws FileNotFoundException {
System.out.println("Hello World!!!");
//创建一个标准字节输出流对象
PrintStream ps=System.out;
ps.println("Java I/O流");
ps.println("Java 666");
ps.println(123);
//标准输出流不需要手动调用close方法关闭
//修改标准字节输出流的输出方向，输出到 log 文件
PrintStream printStream=new PrintStream(new FileOutputStream("E:/log"));
System.setOut(printStream);
//再次输出，将不会输出到控制台
System.out.println("Java I/O流");
System.out.println("Java 666");
System.out.println(999);
}
}
15.Demo 15（I/O流联合Properties属性类使用）
package com.szh.io;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.Properties;
/**
* I/O流和Properties的联合使用
* 设计理念：以后经常改变的数据，可以单独写道一个文件中，使用程序动态读取
* 将来只需要修改这个文件的内容，Java代码不需要修改，不需要重新编译，服务器也不需要重启，就可以拿到动态的数据
*
* 类似于以上机制的文件被称为配置文件，其中的格式为
* key1=value1
* key2=value2 (key重复的情况下，value会自动覆盖)
* 的时候，我们把这种配置文件称为属性配置文件，例如：jdbc.properties
* Java中有规范要求，属性配置文件需要以 .properties 结尾，但这不是必须的
* Properties类是Java中专门存放属性配置文件的一个类
*/
public class IoPropertiesTest {
public static void main(String[] args) throws IOException {
//Properties是一个Map集合，继承了Hashtable，其key和value都是String类型
//这里打算将一个文件中的数据加载到Properties对象中
//新建一个文件字符输入流对象
FileReader reader=new FileReader("E:/userinfo.txt");
//创建一个Properties集合
Properties properties=new Properties();
//调用Properties对象的load方法，将文件中的数据加载到Properties集合中
properties.load(reader);
//通过文件中的key获取对应的value
String username=properties.getProperty("username");
String password=properties.getProperty("password");
System.out.println(username);
System.out.println(password);
}
}
16.Demo 16（File）
package com.szh.io;
import java.io.File;
/**
*
*/
public class FileTest02 {
public static void main(String[] args) {
File file=new File("E:/");
//获取当前目录下的所有子文件
File[] files=file.listFiles();
for (File file1 : files) {
//获取所有子文件的绝对路径
//System.out.println(file1.getAbsolutePath());
//获取所有子文件的文件名
System.out.println(file1.getName());
}
}
}
17.Demo 17（File）
package com.szh.io;
import java.io.File;
/**
*
*/
public class FileTest02 {
public static void main(String[] args) {
File file=new File("E:/");
//获取当前目录下的所有子文件
File[] files=file.listFiles();
for (File file1 : files) {
//获取所有子文件的绝对路径
//System.out.println(file1.getAbsolutePath());
//获取所有子文件的文件名
System.out.println(file1.getName());
}
}
}
18.Demo 18（ObjectInputStream & ObjectOutputStream）
这两个流呢，我在这里就不再举例了，它们两个联合起来主要是实现Java中的序列化和反序列化操作。
在我的这篇文章中有相关的实例：https://blog.csdn.net/weixin_43823808/article/details/116885510
写在结尾
I/O流这块其实就是读读写写的操作，把大体的框架搭建出来，该new对象new对象，该调方法就调方法，遇到什么异常要用什么方法解决（throws直接上抛、还是try/catch捕获），最后记得关闭流、如果是输出流记得刷新。
以上是关于Java——18个Demo带你玩转Java中的I/O流的主要内容，如果未能解决你的问题，请参考以下文章