小议IO流
作者：互联网
IO流
基础IO流
input输出：数据从内存到硬盘的过程叫做输出
output输入：数据从硬盘到内存的过程中叫做输入
流：数据（字符，字节）
一个字符等于两个字节，一个字节=八个二进制
字节流
使用流的时候会造成IO异常，需要再程序中对异常进行声明
文件字节输出流
FileOutputStream
把内存中的数据存储到硬盘中的文件中
写入数据的原理
java->jvm->操作系统->操作系统调入存数据的方法->存入数据
构造方法：
FileOutputStream（File file）
参数为文件路径
FileOutputStream（String file）
参数为文件的字符路径
使用步骤：
1.创建FileOutputStream对象，并传入目的地
2.调用FileOutputStream对象的write方法，将需要写入的数据存入缓冲区
3.调用FileOutputStream对象的flush方法，将缓冲区的文件刷新到目的地文件中去
4.调用FileOutputStream对象的close方法，关闭流。流在使用过程中占用了一定的内存，当我们使用完毕时应关闭流，清理内存，提高程序效率（流一旦关闭将不再能够使用）。
flush和close的方法
flush只是将缓冲区的数据刷新到文件中
close是将缓冲区的数据刷新到文件中并关闭流
import java.io.FileOutputStream;
import java.io.IOException;
public class demo01 {
public static void main(String[] args) throws IOException { //声明异常
FileOutputStream fos = new FileOutputStream("G:\\a\\a.txt");//创建字节输出流的实现类对象
fos.write(97); //写入字节，进入缓冲区
fos.flush(); //刷新缓冲区，字节将写入文件中
fos.close(); //关闭流
}
}
文件字节输入流
FileInputStream
将文件中的字节读取到内存中
构造方法：
1.FileInputStream（File file）
参数为文件路径
2.FileInputStream（Stream file）
参数为字符型的文件路径
使用步骤
1.创建FileInputStream对象，并传入参数，即所以要读取的文件路径
2.调用FileInputStream对象的read方法读取文件的字节
3.调用FileInputStream对象的close方法关闭流，节省内存
注意：
输出流有flush方法
输入流没有flush方法
FileInputStream对象的read方法
不传入参数时，每次调用他都将会读取文件的一个字节，并得到一个返回值，当读到文件末尾时，将会返回-1的返回值
一般可以在read方法的参数中传递byte【】数组，数组长度一般为1024
即FileInputStream.read（byte【1024】）
调用方法时，系统每次会读取参数数组长度的字节，并将读取到的内容存入到参数中，返回值为此次读取到的数据的有效个数，当返回-1时，即代表读取完毕
import java.io.FileInputStream;
import java.io.IOException;
public class demo02 {
public static void main(String[] args) throws IOException { // 抛出IO流异常
FileInputStream fis = new FileInputStream("G:\\a\\a.txt"); //创建输入对象
byte[] b=new byte[1024]; //创建长度为1024的数组
int len=0; //声明整型变量len
while((len=fis.read(b))!=-1){ //用while循环读取文件中的数据，len来接收返回值，byte数组b作为参数，同时也用来存储数据
System.out.print(new String(b)); //将存储数据的参数转化为字符型并打印,
}
fis.close(); // 关闭流
}
}
字符流
一个中文字符占两个两个字节，当我们用字节流来读取中文字符时往往会出现乱码的情况，因此引入字符流
字符输出流
FileWrite
构造方法：
1.FileWrite（File file）
file为输出目的地的文件路径
2.FileWrite (String file)
file为文件目的地的字符类型
使用步骤
1.创建FileWrite对象，构造方法参数中存入写入数据的目的地
2.调用FileWrite的Write方法，参数中存入要输出的数据，数据存入缓冲区
3.调用FileWriter的flush方法，刷新缓冲区中的数据到文件中
4.调用FileWrite的close方法，关闭流
import java.io.FileWriter;
import java.io.IOException;
public class demo03 {
public static void main(String[] args) throws IOException {
FileWriter fw = new FileWriter("G:\\a\\d.txt"); //创建字符输出流对象
fw.write("你好"); //输出字符到缓冲区
fw.flush(); //刷新缓冲区，将缓冲区的数据刷新到文件中
fw.close(); //关闭流
}
}
字符输入流
FileReader
构造方法
1.FileReader（File file）
file为输出目的地的文件路径
2.FileReader（String file）
file为文件目的地的字符类型
使用步骤
1.创建FileReader对象，构造方法中存入输入源文件
2.调用FileReader的Reade的方法读取文件中的数据
3.调用FileReader的close方法，关闭流，节约内存
注意
调用Reader方法时，不传入参数时，每次将会读取文件的一个字符，当读取到最后一个文件时，返回值为-1的整型数据
import java.io.FileReader;
import java.io.IOException;
public class demo04 {
public static void main(String[] args) throws IOException { //声明IO流异常
FileReader fr = new FileReader("G:\\a\\a.txt"); //创建字符输出流对象
int len=0; //声明int型变量用来储存返回值
char[] chars=new char[1024]; // 创建字符数组，用来储存读入的数据
while((len=fr.read(chars))!=-1){ // 遍历输出文件内容
System.out.println(chars);
}
fr.close(); //关闭流
}
}
流的续写与换行
当需要对文件的内容进行续写时，不需要再重新创建文件时
我们可以对文件进行续写。
此时我们创建基础流对象时额外传递一个参数boolean oppend
如果新的参数填写true则该流不会再创建新的文件，会在原文件的后面进行续写
如果新的参数填写false则该流将重新创建新的文件。
import java.io.IOException;
public class demo10 {
public static void main(String[] args) throws IOException { //抛出IO异常
FileWriter fw = new FileWriter("G:\\a\\a.txt", true); //创建字符输出流对象，并对不创建文件，对文件进行续写
fw.write("你好"); //输出数据到缓冲区
fw.flush(); //刷新缓冲区
fw.close(); //关闭流
}
}
与IO流相结合的集合
Properties
他可以将集合中的临时数据存入到硬盘中
他可以将硬盘中的文件读取到集合中，文件中键值对的连接符号默认为=号
将流中的数据存入到文件中
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;
public class demo05 {
public static void main(String[] args) throws IOException { //抛出IO异常
FileWriter fw = new FileWriter("G:\\a\\a.txt"); //创建字符输出流对象
Properties pro = new Properties(); //创建集合
pro.setProperty("加菲猫","8"); //在集合中存入数据
pro.setProperty("波斯猫","9");
pro.store(fw,""); //将集合中数据存入到流的目的地中
}
}
将文件中的数据以取出到集合中并遍历
import java.io.FileReader;
import java.io.IOException;
import java.util.Properties;
import java.util.Set;
public class demo06 {
public static void main(String[] args) throws IOException { //抛出IO异常
Properties pro = new Properties(); //创建集合对象
FileReader fr = new FileReader("G:\\a\\a.txt"); //创建字符输入流对象
pro.load(fr); //通过流找到文件，将文件中的数据存入集合中
Set<String> s=pro.stringPropertyNames();
for(String t:s){
String vall=pro.getProperty(t);
System.out.println(t+vall);
}
fr.close();
}
}
缓冲流
缓冲输出流
BufferedWriter
缓冲输出流，基础流加强版，极大地提高了基础流的输出速度
构造方法
BufferedWriter（File outer）
File outer基础输出流
BufferedWriter（File outer）
使用步骤
1.创建BufferedWriter对象，传出基础输出流作为参数
2.调用BufferedWriter的Writer方法，输出数据到缓冲区
3.调用BufferedWriter的flush方法，刷新缓冲区的数据到文件中
4.调用BufferedWriter的close方法，关闭流，节约内存
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
public class demo07 {
public static void main(String[] args) throws IOException {
BufferedWriter bfw = new BufferedWriter(new FileWriter("G:\\a\\a.txt"));
bfw.write(98);
bfw.write(97);
bfw.write(99);
bfw.write(100);
bfw.flush();
bfw.close();
}
}
缓冲输入流
BufferedReader
基础输入流的加强版，极大地提高了输入流的效率
构造方法
1.BufferedReader（FIleInput intput）
Intput基础输入流
使用步骤
1.创建BufferedReader对象，参数传入基础输入流
2.调用BufferedReader的Reader方法，读取文件中的字节。
3.调用BufferedReader的close方法，关闭流
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class demo08 {
public static void main(String[] args) throws IOException { //抛出IO异常
BufferedReader bfr = new BufferedReader(new FileReader("G:\\a\\a.txt")); //创建缓冲输入流对象，传递基础流作为参数
char[] c=new char[1024]; //创建char数组，用来存储读取到的数据
int len=0; //声明int整型变量，用来存储返回值
while((len= bfr.read(c))!=-1){ //遍历输出文件中的内容
System.out.println(c);
}
bfr.close(); //关闭流
}
}
编码与解码
我们在计算机中存储数据时，计算机会将数据转化为字节进行存储，这一过程叫做编码
我们在读取数据时，计算机会将我们读取的数据从字节转化回来，这一过程叫做解码
编码和解码时往往会有一个依据，这个依据可以理解为密码本。
windows的密码本为gbk
ide的密码本默认为ut-8
当我们在编码和解码时采用不同的密码本时，往往不能读取出来正确的数据，这是就会出现乱码现象
这是我们可以借用IO流中的转化流来解决这一问题
转换输出流
OutputStreamWriter
构造方法
1.OutputStreamWriter（FileOutput out）
FileOutput out为基础字节输出流
2.OutputStreamWriter （FileOutput put，String charsetname）
FileOutput out为基础输出流，String charsetname为编码表，不需要区分大小写
不填入编码表时将默认java的ut-8编码表
使用步骤
1.创建OutputStreamWriter对象，传入基础输出流作为参数，可选择传入数据编码类型
2.调用OutputStreamWriter的Writer方法，参数中写入需要输出的数据
3.调用OutputStreamWriter的flush方法，刷新缓冲区的数据到文件中
4.调用OutputStreamWriter的close方法，关闭流
import java.io.*;
public class demo09 {
public static void main(String[] args) throws IOException { //抛出Io异常
OutputStreamWriter gbk = new OutputStreamWriter(new FileOutputStream("G:\\a\\a.txt"), "gbk");//创建转换流对象，并设置编码形式为gbk
gbk.write("你好"); //输出数据到缓冲区
gbk.flush(); //刷新缓冲区
gbk.close(); //关闭流
}
}
转化输入流
InputStreamReader
构造方法
1.InputStreamReader（Input in）
Input为基础字节输入流
2.InputSreamReader (Input in,String charsetname)
Input为基础字节输入流
String charsetname为解码格式，不区分大小写
不填写解码表时默认为utf-8
使用步骤
1.创建InputStreamReader对象，并传入参数，可选择填入解码表
2.调用InputStreamReader对象的Reader方法，读取目的地文件的数据
3.调用InputStreamReader对象的close方法，关闭流
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
public class demo11 {
public static void main(String[] args) throws IOException { //抛出IO异常
InputStreamReader isr = new InputStreamReader(new FileInputStream("G:\\a\\a.txt"), "utf-8");//创建转化流并将并传入基础字节流，确定解码表
char[] chars = new char[1024]; //创建数组，用来接收读取到的数据
int len = 0; //声明整型数据，用来接收返回值
while ((len = isr.read(chars)) != -1) { //遍历读取到的文件内容
System.out.println(chars);
}
}
}
序列化与反序列化
当我们需要存储我们创建的对象，我们可以借助流将其存贮在文件中，当我们需要使用时同时也可以借助流，将文档中的对象提取出来。
将对象存储在文件中这一个过程叫做对象的序列化
将对象从文件中提取出来这一过程叫做对象的反序列化
序列化
ObjectOutputStream
构造方法
1.ObjectOutputStream（Output out）
Out为基础字节输出流
使用步骤
1.创建ObjectOutputStream对象，传出参数基础字节流
2.创建自定义对象
3.调用ObjectOutputStream的WriteObject方法，将自定义对象写入缓冲区中
4.调用ObjectOutputStream的flush方法，将缓冲区的内容刷新到文件中
5.调用ObjectOutputStream的close方法，关闭流，节约内存
注意
并不是所有的对象都可以序列化，只有实现了Serializable接口的类对象才可以序列化。
进行序列化的时候jvm会对需要序列化的对象进行检测，当检测到他的类实现了Serializable接口才会成功序列化，如果检测不到Serializable接口，则序列化失败
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
public class demo12 {
public static void main(String[] args) throws IOException {
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("G:\\a\\a.txt"));
oos.writeObject(new cat("加菲猫",9));
oos.flush();
oos.close();
}
}
反序列化
ObjectIntputStream
构造方法
1.ObjectIntputStream(FileIntput Intput)
Intput基本字节输入流
2.ObjectIntputStream（FileIntput Intput,String charsetname）
Intput基本字节输入流,String charsetname
使用步骤
1.创建ObjectIntputStream对象，并传入参数
2.调用ObjectIntputStream对象的Reader方法读取文档中的对象
3.输出对象
4.调用ObjectIntputStream对象的close方法关闭流
注意
反序列化的过程中，会报出class异常，我们需要抛出此异常。
异常生成原因，正常的工程序列化过程中会生成class文件，没有生成class文件但是需要返序列化的时候就会抛出异常
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
public class demo13 {
public static void main(String[] args) throws IOException, ClassNotFoundException { //抛出IO异常和Class异常
ObjectInputStream gbk = new ObjectInputStream(new FileInputStream("G:\\a\\a.txt")); //创建反序列化对象
Object o=gbk.readObject(); //读取文件中的对象,并用Object接收
cat c=(cat)o; //将接收到的对象转化为Cat型
System.out.println(c.getName()+c.getAge()); //输出对象属性
gbk.close(); //关闭流
}
}
标签：小议,java,IO,文件,io,new,import,public 来源： https://blog.csdn.net/m0_54355376/article/details/114874384