文章目录
- 1 InputStream
- 2 OutputStream
- 3 文件拷贝（字节流）
- 4 FileReader、 FileWriter
- 5 文件拷贝（字符流）
- 6 节点流和处理流
- 7 ObjectOutputSteam和ObjectInputStream---序列化和反序列化
- 8 转换流
- 结语
📖
个人介绍
大家好我是：一颗松
认真分享技术，记录学习点滴
如果分享对你有用请支持我哦🍺
点赞：👍 留言：✍收藏：⭐️
个人格言： 想法落实的最佳时机就是现在！🏄
1 InputStream
代码示例：
public class FileInputStreamDemo {
public static void main(String[] args) throws Exception {
// 定义文件路径
String str = "E:\\Codes\\myProject\\fileInputStreamTest.txt";
// 创建FileInputStream对象
FileInputStream fileInputStream = new FileInputStream(str);
// 创建一个8个字节的缓冲空间
byte buffer [] = new byte[8];
int length = 0;
while ((length = fileInputStream.read(buffer)) != -1){
System.out.println(new String(buffer,0,length));
}
}
} 2 OutputStream
代码示例：
此种方式数据写入文件，是覆盖源文件；
public class FileOutputSteamDemo {
public static void main(String[] args) throws IOException {
String str = "E:\\Codes\\myProject\\fileInputStreamTest.txt";
OutputStream outputStream = new FileOutputStream(str);
byte [] buffer = "gym.IverryverryLoveyou".getBytes();
try {
outputStream.write(buffer);
} catch (IOException e) {
e.printStackTrace();
}finally {
outputStream.close();
}
System.out.println("完成写入");
}
} 如果想实现数据写入文件，追加而不是覆盖则可以采用以下构造器：
- public FileOutputStream( filesrc, boolean append)
参数append为true时则，追加数据，不覆盖，
3 文件拷贝（字节流）
拷贝代码示例
public class IOCopyDemo {
public static void main(String[] args) throws IOException {
String str = "E:\\Codes\\myProject\\copyTest.txt";
String str2 = "E:\\Codes\\myProject\\coptTest2.txt";
// 创建输入流对象
FileInputStream fileInputStreamDemo = new FileInputStream(str);
// 创建输出流对象
FileOutputStream fileOutputStream = new FileOutputStream(str2);
// 创建缓冲
byte buffer [] = new byte[8];
int leng = 0;
// 用循环实现拷贝
try {
while ((leng = fileInputStreamDemo.read(buffer))!=-1){
fileOutputStream.write(buffer,0,leng);
}
} finally {
if (fileOutputStream != null || fileInputStreamDemo != null){
fileInputStreamDemo.close();
fileOutputStream.close();
}
}
System.out.println("拷贝完成");
}
}
4 FileReader、 FileWriter
FileWriter同样有两种模式，覆盖模式，和追加模式；
覆盖模式；使用以下构造器
- public FileWriter( fileName)
使用下面构造器append 设置为true是是追加模式；
- public FileWriter( fileName, boolean append)
注意事项：FileWriter使用之后必须关闭(close)或者刷新（flush），否则写不到文件中；
5 文件拷贝（字符流）
public class CopyDemo2 {
public static void main(String[] args) throws FileNotFoundException {
String str = "E:\\Codes\\myProject\\fileWriter.txt";
String str2 = "E:\\Codes\\myProject\\fileCopy.txt";
// 创建字符输入流
FileReader fileReader = new FileReader(str);
char [] array = new char[10];
int leng=0;
// 创建字符输出流
try {
FileWriter fileWriter = new FileWriter(str2);
while ((leng = fileReader.read(array)) !=-1){
String s =new String(array,0,leng);
fileWriter.write(s);
// 刷新字符输出流
fileWriter.flush();
}
} catch (IOException e) {
e.printStackTrace();
}finally {
}
}
}
6 节点流和处理流
节点流是针对某个特定的数据源读写，如FileWriter、FileReader；处理流也叫包装流，连接已存在的流，为程序提供更强大的功能如BufferWriter、BufferReader；
7 ObjectOutputSteam和ObjectInputStream—序列化和反序列化
此处理流（包装流），提供了对基本类型或者对象类型的序列化和反序列化的方法；
ObjectOutputStream：提供了序列化的方法
ObjectInputStream：提供了反序列化的方法
序列化： 就是将数据与数据类型都保存起来，叫序列化；
反序列化：指将序列化的数据恢复到原来；
注意：如果想让某个对象支持序列化，则必须让其类是可序列化的，也就是必须让类实现两个接口：
Sarializable:标记接口，没有方法（推荐使用）
Externalizable：该接口有方法需要实现
序列化代码示例：
public class SerializableDemo {
public static void main(String[] args) throws IOException {
// 创建被序列化对象
Person xiaoM = new Person("小明",18);
// 创建文件路径
String str = "E:\\Codes\\myProject\\ObjectOut.dat";
// 创建处理流对象
ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream(str));
outputStream.writeObject(xiaoM);
outputStream.close();
System.out.println("序列化完成");
}
}
class Person implements Serializable {
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
/**
* 获取
* @return name
*/
public String getName() {
return name;
}
/**
* 设置
* @param name
*/
public void setName(String name) {
this.name = name;
}
/**
* 获取
* @return age
*/
public int getAge() {
return age;
}
/**
* 设置
* @param age
*/
public void setAge(int age) {
this.age = age;
}
public String toString() {
return "Person{name = " + name + ", age = " + age + "}";
}
}
反序列化代码示例：
public class ReSerializableDmeo {
public static void main(String[] args) throws IOException, ClassNotFoundException {
// 定义变量接收，反序列化数据
Person person = null;
// 创建文件路径
String str = "E:\\Codes\\myProject\\ObjectOut.dat";
// 创建ObjectInputStream对象
ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(str));
person = (Person) objectInputStream.readObject();
objectInputStream.close();
System.out.println("反序列化完成！");
System.out.println("姓名："+person.getName()+" 年龄："+person.getAge());
}
}
序列化过程中需要注意的事项：
（1）：读写顺序要一致
（2）：要实现序列化的的对象，类必须实现Serializable接口
（3）：序列化类中建议添加 SerialVersionUID,可以提高版本兼容性
（4）：序列化时会默认将里面所有属性都序列化了，但是被static和transient修饰的属性不会被序列化；
（5）：序列化时要求里面属性的类型也需要实现序列化接口
（6）：序列化具有可继承性
8 转换流
InputStreamReader和OutputStreamWriter
代码示例：
public class InputStreamReaderDemo {
public static void main(String[] args) throws IOException {
String str = "E:\\Codes\\myProject\\fileWriter.txt";
InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream(str),"gbk");
BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
String s = null;
while ((s = bufferedReader.readLine()) != null){
System.out.println(s);
bufferedReader.lines();
}
inputStreamReader.close();
bufferedReader.close();
}
}
结语
大佬请留步IO流再回顾，深入理解序列化和反序列化