Java IO的讲解
IO的概念
IO：Java对数据的操作是通过流的方式，IO流用来处理设备之间的数据传输，上传文件和下载文件，Java用于操作流的对象都在IO包中。
IO的分类
- 按功能来分：输入流（input）、输出流（output）。
- 按类型来分：字节流和字符流。
- 区别:字节流按 8 位传输以字节为单位输入输出数据，字符流按 16 位传输以字符为单位输入输出数据。
字节流跟字符流有哪些
- 字节输入流(InputStream)：字节输入流分为：FileInputStream 和 BufferedInputStream
- 字节输出流(OutputStream):字节输出流分为：FileOutputStream 和Buffered
OutoutStream - 字符输入流(Reader):字符输入流分为:InputStreamReader(转化流)–>FileReader 和
BufferedReader - 字符输出流：字符流分为：OutputStreamWrite(转化流)–>FileWrite 和BufferedWrite
字节流常用的方法
InputStream：字节输入流基类，抽象类是表示字节输入流的所有类的超类。
常用方法：
// 从输入流中读取数据的下一个字节
abstract int read()
// 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b中
int read(byte[] b)
// 将输入流中最多 len 个数据字节读入 byte 数组
int read(byte[] b, int off, int len)
// 跳过和丢弃此输入流中数据的 n个字节
long skip(long n)
// 关闭此输入流并释放与该流关联的所有系统资源
void close()
字符流常用的方法
OutputStream：字节输出流基类，抽象类是表示输出字节流的所有类的超类。
常用方法：
// 将 b.length 个字节从指定的 byte 数组写入此输出流
void write(byte[] b)
// 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流
void write(byte[] b, int off, int len)
// 将指定的字节写入此输出流
abstract void write(int b)
// 关闭此输出流并释放与此流有关的所有系统资源
void close()
// 刷新此输出流并强制写出所有缓冲的输出字节
void flush()
字节文件操作流
FileInputStream：字节文件输入流，从文件系统中的某个文件中获得输入字节，用于读取诸如图像数据之类的原始字节流。
构造方法：
// 通过打开一个到实际文件的连接来创建一个FileInputStream，该文件通过文件系统中的File对象file指定
FileInputStream(File file)
// 通过打开一个到实际文件的连接来创建一个FileInputStream，该文件通过文件系统中的路径name指定
FileInputStream(String name)
实例
// 读取d盘下该文件d://test.txt
//构造方法1
InputStream input = new FileInputStream(new File(d://test.txt));
int len = 0;
//一次读取一个字节
while ((len = input .read()) != -1) {
System.out.print((char) len + " ");
}
//关闭IO流
input.close();
// 读取d盘下该文件d://test.txt
//构造方法1
InputStream input = new FileInputStream(new File(d://test.txt));
Byte[] by = new Byte[1024];
int len = 0;
//一次读取一个字节
while ((len = input .read(by)) != -1) {
System.out.print(new String(by,0,len));
}
//关闭IO流
input.close();
注意了 这样使用完记得关闭流操作
FileOutputSteam：字节文件输出流是用于将数据写入到File，从程序中写入到其他位置。
构造方法：
// 创建一个向指定File对象表示的文件中写入数据的文件输出流
FileOutputStream(File file)
// 创建一个向指定File对象表示的文件中写入数据的文件输出流
FileOutputStream(File file, boolean append)
// 创建一个向具有指定名称的文件中写入数据的输出文件流
FileOutputStream(String name)
// 创建一个向具有指定name的文件中写入数据的输出文件流
FileOutputStream(String name, boolean append)
实例
OutputStream out = new FileOutputStream(new File("d://test.txt"));
// 写出数据到文件中
out .write("ABCD".getBytes());
// 关闭IO流(每次使用完记得关闭)
out .close();
// 内容追加写入 第二个参数的boolean类型 意思就是是否追加的意思
OutputStream out2 = new FileOutputStream("d://test.txt", true);
// 输出换行符
out2 .write("\r\n".getBytes());
// 输出追加内容
out2 .write("helloWord".getBytes());
// 关闭IO流(每次使用完记得关闭)
out2 .close();
字节缓冲流（高效流）
BufferedInputStream：字节缓冲输入流，提高了读取效率。
构造方法：
// 创建一个 BufferedInputStream并保存其参数，即输入流in，以便将来使用。
BufferedInputStream(InputStream in)
// 创建具有指定缓冲区大小的 BufferedInputStream并保存其参数，即输入流in以便将来使用
BufferedInputStream(InputStream in, int size)
实例
InputStream in = new FileInputStream("d://a.txt");
// 字节缓存流
BufferedInputStream bfi = new BufferedInputStream(in);
byte[] by = new byte[20];
int len = 0;
while ((len = bfi.read(by)) != -1) {
System.out.print(new String(by, 0, len));
}
// 关闭流
bfi.close();
BufferedOutputStream ：字节缓冲输出流，提高了写入效率。
构造方法：
// 创建一个新的缓冲输出流，以将数据写入指定的底层输出流
BufferedOutputStream(OutputStream out)
// 创建一个新的缓冲输出流，以将具有指定缓冲区大小的数据写入指定的底层输出流
BufferedOutputStream(OutputStream out, int size)
常用方法：
// 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此缓冲的输出流
void write(byte[] b, int off, int len)
// 将指定的字节写入此缓冲的输出流
void write(int b)
// 刷新此缓冲的输出流
void flush()
实例
BufferedOutputStream bfo = new BufferedOutputStream(new FileOutputStream("d://a.txt", true));
// 输出换行符
bfo.write("\r\n".getBytes());
// 输出内容
bos.write("helloWord".getBytes());
// 刷新此缓冲的输出流
bos.flush();
// 关闭流
bos.close();
字符操作流
Reader:读取字符流的抽象类.
常用方法：
// 读取单个字符
int read()
// 将字符读入数组
int read(char[] cbuf)
// 将字符读入数组的某一部分
abstract int read(char[] cbuf, int off, int len)
// 关闭该流并释放与之关联的所有资源
abstract void close()
Write :写入字符流的抽象类
常用方法：
// 写入字符数组
void write(char[] cbuf)
// 写入字符数组的某一部分
abstract void write(char[] cbuf, int off, int len)
// 写入单个字符
void write(int c)
// 写入字符串
void write(String str)
// 写入字符串的某一部分
void write(String str, int off, int len)
// 将指定字符添加到此 writer
Writer append(char c)
// 将指定字符序列添加到此 writer
Writer append(CharSequence csq)
// 将指定字符序列的子序列添加到此 writer.Appendable
Writer append(CharSequence csq, int start, int end)
// 关闭此流，但要先刷新它
abstract void close()
// 刷新该流的缓冲
abstract void flush()
字符缓冲流（高效流）
BufferedWrite：字符缓冲输入流，提高了写入效率。
实例
//创建写入的对象
Writer w = new FileWriter("d://a.txt");
//创建输入字符缓冲流
BufferedWriter bfw = new BufferedWriter(w);
//写入一个字符串(上面有具体的方法 可以去参考)
bfw.write("helloWord");
//刷新缓冲流
bfw.flush();
//关闭缓冲流
bfw.close();
//关闭输入字符流
w.close();
BufferedReader : 字符缓冲输出流，提高了读取效率。
实例
BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream("d://a.txt")));
String str="";
//一次性读取一行,读取的不同方式查看上面的方法
while ((str = reader.readLine()) != null) {
System.out.println(str);
}
//关闭流
reader.close();
序列化与反序列化
概念
序列化：把对象转换为字节序列的过程称为对象的序列化。
反序列化：把字节序列恢复为对象的过程称为对象的反序列化。
序列化与反序列化都要对对象实现Serializable接口
ObjectOutputStream(序列化)
实例
//创建序列化对象
ObjectOutputStream objOut = new ObjectOutputStream(new FileOutputStream("d://a.txt"));
//调用WriteObject方法把对象写入到本地这里的Book是的实体(对象)
objOut.writeObject(book);
//刷新缓存
objOut.flush();
//关闭流
objOut.close();
ObjectInputStream(反序列化)
实例
//创建反序列化对象
ObjectInputStream objIn= new ObjectInputStream(new FileInputStream("d://a.txt"));
//调用readObject 方法 后强转为对象类型(这里也可以进行判断是不是该对象)
Book book=(Book)objIn.readObject();
//输出对象，我这里重写toString 所以直接输出
System.out.println(book);
//关闭流
objIn.close();
写得不好，仅供参考，如有写错的可以联系我进行改进
转载：https://blog.csdn.net/xiaoyanghnl/article/details/104947603
查看评论