DataInputStream和DataOutputStream类
DataInputStream和DataOutputStream类创建的对象称为数据输入流和数据输出流。这两个流是很有用的两个流,它们允许程序按着机器无关的风格读取Java原始数据。也就是说,当读取一个数值时,不必再关心这个数值应当是多少个字节。
以下是DataInputStream和DataOutputStream的构造方法。
DataInputStream(InputStream in)创建的数据输入流指向一个由参数in指定的底层输入流。
DataOutputStream(OutnputStream out)创建的数据输出流指向一个由参数out指定的底层输出流。
package demo01;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
public class DateInputStreamAndDateOutputStream {
public static void main(String[] args) {
//创建InputStream类对象,但是InputStream类是一个抽象类,不能直接创建对象,
// 可以创建引用指向其子类
InputStream is =null;
//创建DataInputStream类对象
DataInputStream dis =null;
//创建OutputStream类对象,但是OutputStream类是一个抽象类,不能直接创建对象,
// 可以创建其引用指向其子类
OutputStream os = null;
//创建DataOutputStream类对象
DataOutputStream dos = null;
try {
is = new FileInputStream("F:/car.jpg");
dis = new DataInputStream(is);
os = new FileOutputStream("F:/runCar.jpg");
dos = new DataOutputStream(os);
int num;
while((num=dis.read())!=-1){
dos.write(num);
}
System.out.println("图片复制完毕");
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
dos.close();
os.close();
dis.close();
is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
序列化和反序列化
序列化是将对象的状态写入到特定的流中的过程
反序列化则是从特定的流中获取数据重新构建对象的过程
实现序列化的步骤:
注意:使用集合保存对象,可以将集合中的所有对象序列化
实现反序列化的步骤:
注意:如果向文件中使用序列化机制写入多个对象,那么反序列化恢复对象时,必须按照写入的顺序读取
对象流:ObjectInputStream和ObjectOutputStream类
ObjectInputStream和ObjectOutputStream类分别是InputStream和OutputStream类的子类。ObjectInputStream和ObjectOutputStream类创建的对象称为对象输入流和对象输出流。对象输出流使用writeObject(Object obj)方法将一个对象 obj写入到一个文件,对象输入流使用readObject()读取一个对象到程序中。
ObjectInputStream和ObjectOutputStream类的构造方法如下。 ObjectInputStream(InputStream in)
ObiectOutputStream(OutputStream out)
当使用对象流写入或读入对象时,要保证对象是序列化的。这是为了保证能把对象写入到文件,并能再把对象正确读回到程序中。
一个类如果实现了Serializable 接口(java.io 包中的接口),那么这个类创建的对象就是所谓序列化的对象。Java 类库提供的绝大多数对象都是所谓序列化的。需要强调的是,Serializable接口中没有方法,因此实现该接口的类不需要实现额外的方法。另外需要注意的是,使用对象流把一个对象写入到文件时不仅要保证该对象是序列化的,而且该对象的成员对象也必须是序列化的。
Serializable接口中的方法对程序是不可见的,因此实现该接口的类不需要实现额外的方法,当把一个序列化的对象写入到对象输出流时,JVM就会实现Serializable接口中的方法,将一-定格式的文本(对象的序列化信息)写入到目的地。当ObjectInputStream对象流从文件读取对象时,就会从文件中读回对象的序列化信息,并根据对象的序列化信息创建一一个对象。
package demo02;
import java.io.Serializable;
public class Student implements Serializable {
private String name;
private int age;
private double score;
public Student() {
super();
}
public Student(String name, int age, double score) {
super();
this.name = name;
this.age = age;
this.score = score;
}
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;
}
public double getScore() {
return score;
}
public void setScore(double score) {
this.score = score;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + ", score=" + score
+ "]";
}
}
序列化 :
package demo02;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
public class ObjectOutputStreamDemo01 {
public static void main(String[] args) {
//创建一个Student对象
Student stu = new Student("张三", 22, 99.5);
//创建OutputStream类对象
OutputStream os = null;
//创建ObjectOutputStream类对象
ObjectOutputStream oos =null;
try {
os = new FileOutputStream("F:/student.txt");
oos = new ObjectOutputStream(os);
oos.writeObject(stu);
System.out.println("对象存储完毕");
}catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
oos.close();
os.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
反序列化:
package demo02;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
public class ObjectInputStreamDemo01 {
public static void main(String[] args) {
//创建InputStream类对象,但是InputStrteam类是抽象类,不能直接创建其对象,只能创建其引用指向其子类对象
InputStream is =null;
//创建ObjectInputStream类对象
ObjectInputStream ois = null;
try {
is = new FileInputStream("F:/student.txt");
ois = new ObjectInputStream(is);
//从文件中读取对象
Object object = ois.readObject();
//将读取的对象通过向下转型为其真实类型
Student stu =(Student) object;
System.out.println(stu);
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}finally{
try {
ois.close();
is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
输入输出流17个类,均可在API中查出所有信息