输入输出流及其17个类（二）

 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中查出所有信息