-DAY19-IO流（3）字符流、对象流
字符流:
| Reader | 这个抽象类表示字符输入流的所有类的父类 |
| Writer | 这个抽象类表示字符输出流的所有类的父类 |
| OutputStreamWrite | 文件字符输出流(具体的字符输出流实现类) |
| OutputStreamWrite(OutputStream out) | 创建文件字节输出流写入文件 |
步骤:
1.创建对象
2.关闭
3.调用方法
构造:
OutputStreamWrite(OutputStream out)
OutputStreamWrite(OutputStream out,Charset cs)
方法:
| 方法 | 说明 |
|---|---|
| void write(int c) | 写一个字符 |
| void write(char[] cbuf) | 写一个字符数组 |
| void write(char[] cbuf,int off,int len) | 写一个字符数组的一部分 |
| void write(String str) | 写一个字符串 |
| void write(String str,int off,in len) | 写一个字符串的一部分 |
InputStreamReader(InputStream in):
文件字符输入流(具体的字符输入流实现类)
使用步骤:
1.创建对象
2.关闭
3.调用方法
构造:
InputStreamReader(InputStream in) 创建一个使用默认字符集的InputStreamReader。
InputStreamReader(InputStream in, Charset cs) 创建一个使用给定字符集的InputStreamReader。
方法:
| 方法 | 说明 |
|---|---|
| void read() | 读一个字符 |
| void read(char[] cbuf) | 读一个char数组 |
| void read(char[] cbuf,int offset,int len) | 将字符读入数组的一部分 |
注意:
字符流构造中的参数不是具体的文件路径 而是字节流对象
说明了字符流操作具体的文件内容时,本质上还是通过字节流 操作
字符流简便写法:
FileReader:
FileWriter:
package javaDemo.IOdemo;
import java.io.FileWriter;
public class FileWriterDemo {
public static void main(String[] args) throws Exception {
FileWriter fw = new FileWriter("D:\\ideafile\\Bigdata\\5.txt");
fw.write("我");
fw.write("和");
fw.write("你");
fw.write("\r\n");
fw.write("你爱我");
fw.flush();
fw.close();
FileWriter fw2 = new FileWriter("D:\\ideafile\\Bigdata\\5.txt");
fw2.write("cool");//新定义的对象写入会将前一个写入的信息覆盖
fw2.flush();
fw2.close();
// 实现追加的功能
FileWriter fw3 = new FileWriter("D:\\ideafile\\Bigdata\\5.txt", true);
fw3.write("\r\n");
fw3.write("IDEA");
fw3.write("666");
fw3.flush();
fw3.close();
}
}
package javaDemo.IOdemo;
import java.io.FileReader;
public class FileReaderDemo {
public static void main(String[] args) throws Exception{
FileReader frd = new FileReader("D:\\ideafile\\Bigdata\\4.txt");
int temp=0;
while ((temp=frd.read())!=-1) {
System.out.print((char)temp);
}frd.close();
}
}
为什么字符缓冲流?
字节和字符读取一整行数据会有问题?
windwos中换行符\r\n,java代码判断换行符只能给\r或\n,剩下的是数据
BufferedRead:
从字符输入流读取文本，缓冲字符，以提供字符，数组和行的高效读取。 可以指定缓冲区大小，或者可以使用默认大小。 默认值足够大，可用于大多数用途。
BufferedWrite:
将文本写入字符输出流，缓冲字符，以提供单个字符，数组和字符串的高效写入。 可以指定缓冲区大小，或者可以接受默认大小。 默认值足够大，可用于大多数用途。
构造方法:
BufferedRead(Read in);
BufferedWrite(Write out);
特殊操作方式:
读:readLine():读取一行(不需要关心换行符)
写:newLine():直接写换行(不需要关心换行符)
package javaDemo.IOdemo;
import java.io.BufferedReader;
import java.io.FileReader;
public class BufferedReaderDemo {
public static void main(String[] args)throws Exception {
BufferedReader br = new BufferedReader(new FileReader("D:\\ideafile\\Bigdata\\5.txt"));
String temp="";
while ((temp=br.readLine())!=null){
System.out.print(temp);
}
br.close();
}
}
package javaDemo.IOdemo;
import java.io.BufferedWriter;
import java.io.FileWriter;
public class BufferedWriterDemo {
public static void main(String[] args) throws Exception{
BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\ideafile\\Bigdata\\6.txt"));
bw.write("我");
bw.write("和");
bw.write("你");
bw.newLine();
bw.write("你爱我");
bw.close();
}
}
Object对象序列化:
序列化:对象通过字节序列保存到文件中,把对象中的所有内容存储(看的懂的:属性的值,对象的类.....;看不懂的:类的结构,存储位置.....)
反序列化:把文件中的对的内容在通过字节序列在拿出来
持久化:
内存和硬盘数据的相互转换
对象序列化:就是将对象保存到磁盘中,或者在网络中传输对象 这种机制就是使用一个字节序列表示一个对象,该字节序列包含:对象的类型，对象中存储的对象详细信息
字节序列写入到文件之后,相当于文件持久保存了一个对象的信息 反之,改该字节序列也可以从文件中读取对象信息,称之为反序列化
对象流:
| 对象序列化流 | ObjectOutputStream |
| 对象反序列化流 | ObjectInputStream |
方法:
| readerObject(); | - |
| writerObject(); | - |
Student类
package Day21.Demo.demo01;
import java.io.Serializable;
public class Student implements Serializable {
private int id;
private String name;
private int age;
public Student() {
}
public Student(int id, String name, int age) {
this.id = id;
this.name = name;
this.age = age;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
ObjectOutPutStreamObject（序列化）
package Day21.Demo.demo01;
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
//序列化
public class ObjectOutPutStreamObject {
public static void main(String[] args)throws Exception {
ObjectOutputStream oos = new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream("D:\\ideafile\\Bigdata\\10")));
Student student = new Student(1,"zs",18);
oos.writeObject(student);
oos.flush();
oos.close();
}
}
ObjectInputStreamObjectTypeDemo（反序列化）
package Day21.Demo.demo01;
import java.io.FileInputStream;
import java.io.ObjectInputStream;
public class ObjectInputStreamObjectTypeDemo {
public static void main(String[] args) throws Exception{
ObjectInputStream ois = new ObjectInputStream(
new FileInputStream("D:\\ideafile\\Bigdata\\10"));
Student student=(Student)ois.readObject();
System.out.println(student.getId()+"-----"+student.getName()+"-----"+student.getAge());
ois.close();
}
}
注意:
一个对象想要实现序列化，该对象必须实现Serializable接口
Serializable是一个标识接口(标识可以进行序列化)，实现该接口，不需要重写任何方法
①
序列化一个对象之后,类文件发生更改,会出现InvalidClassException:因为当序列化运行时检测到类中的以下问题之一时抛出。
类的串行版本与从流中读取的类描述符的类型不匹配
该类包含未知的数据类型
该类没有可访问的无参数构造函数
解决方案:
在类中增加一个版本标识信息(序列化对象时,会由系统分配的版本标识)
protected static final long serialVersionUID = 42L;
② 成员变量如何不被序列化？
给该成员加上一个transient关键字修饰，标识了该成员不参与序列化
Student
package Day21.Demo.demo01;
import java.io.Serializable;
public class Student implements Serializable {
private int id;
private transient String name;//加上一个transient关键字修饰，标识了该成员不参与序列化
private int age;
private static final long serialVersionUID = 6;//设置版本标识信息
public Student() {
}
public Student(int id, String name, int age) {
this.id = id;
this.name = name;
this.age = age;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
ObjectOutPutStreamObject（序列化）
package Day21.Demo.demo01;
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
//序列化
public class ObjectOutPutStreamObject {
public static void main(String[] args)throws Exception {
ObjectOutputStream oos = new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream("D:\\ideafile\\Bigdata\\10")));
Student student = new Student(1,"zs",18);
oos.writeObject(student);
oos.flush();
oos.close();
}
}
ObjectInputStreamObjectTypeDemo（反序列化）
package Day21.Demo.demo01;
import java.io.FileInputStream;
import java.io.ObjectInputStream;
public class ObjectInputStreamObjectTypeDemo {
public static void main(String[] args) throws Exception{
ObjectInputStream ois = new ObjectInputStream(
new FileInputStream("D:\\ideafile\\Bigdata\\10"));
Student student=(Student)ois.readObject();
System.out.println(student.getId()+"-----"+student.getName()+"-----"+student.getAge());
ois.close();
}
}
|
|
|
|
|
|
上一章节-DAY19-IO流（2）BufferedStream
下一章节-java篇-DAY22-多线程(1)Thread&runnable
肯定没有人会有人给我👍、✉、😍。呜呜555555555555555/(ㄒoㄒ)/~
😭
😭
😭
😭
扫一扫
7988
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
