ObjectInputStream和ObjectInputStream类创建的对象被称为对象输入流和对象输出流。
创建文件输出流代码：
FileOutputStream file_out = new FileOutputStream(“student.dat”);
ObjectOutputStream object_out = new ObjectOutputStream(file_out);
创建文件输入流代码：
FileInputStream file = new FileInputStream( "student.dat ");
ObjectInputStream ois = new ObjectInputStream(file);
问题描述：
向一个文件中写入一个对象，可以用ObjectOutputStream套接FileOutputStream来实现（序列化）。但如果想向一个文件中写入多个对象并且能够正确读出来，用它们该如何实现？一种方法是在FileOutputStream和ObjectOutputStream之间再套接一个BufferedInputStream，每写入一个对象，换一行，再写个对象，再换一行。读取的时候，同样在中间套接个FileInputStream，每读一行，读出一个对象，再读一行，又读出个对象。然而这种方法非常的繁琐，且效率低。
知识储备：
使用对象流写入或读入对象时，要保证对象是序列化的。这是为了保证能把对象写入到文件，并能再把对象读回到程序中的缘故。一个类如果实现了Serializable接口，那么这个类创建的对象就是所谓序列化的对象。所谓“对象序列化”：简单一句话：使用它可以象存储文本或者数字一样简单的存储对象。一个应用是，程序在执行过程中突然遇到短电或者其他的故障导致程序终止，那么对象当前的工作状态也就会丢失，这对于有些应用来说是可怕的。用对象序列化就可以解决这个问题，因为它可以将对象的全部内容保存于磁盘的文件，这样对象执行状态也就被存储了，到需要时还可以将其从文件中按原样再读取出来，这样就解决了数据丢失问题。对象序列化可以简单这么实现：为需要被序列化的对象实现Serializable接口，该接口没有需要实现的方法，implements Serializable只是为了标注该对象是可被序列化的，然后使用一个输出流(如：FileOutputStream)来构造一个ObjectOutputStream(对象流)对象，接着，使用ObjectOutputStream对象的writeObject(Object obj)方法就可以将参数为obj的对象写出(即保存其状态)，要恢复的话则用输入流。
上述问题解决方法：
该对象首先要可序列化,然后把多个对象存储到容器里,如ArrayList<?> list;
然后把list序列化存储,读出来就是一串对象了。
例子一：参考资料http://dev.csdn.net/article/31/31129.shtm，
http://zhidao.baidu.com/question/26665922.html?si=4
import java.io.*;
import java.util.*;
public class ObjectFileTest
{
public static void main(String[] args)
{
Manager boss = new Manager("Carl Cracker", 80000, 1987, 12, 15);
boss.setBonus(5000);
Employee[] staff = new Employee[3];
staff[0] = boss;
staff[1] = new Employee("Harry Hacker", 50000, 1989, 10, 15);
staff[2] = new Employee("Tony Tester", 40000, 1990, 1, 15);
try
{
/**
*使用文件输出流构造一个对象输出流
*FileOutputStream文件输出流
*ObjectOutputStream对象输出流
*/
ObjectOutputStream out = new ObjectOutputStream(new
FileOutputStream("employee.dat"));
out.writeObject(staff); //将对象写入"employee.dat"中
out.close(); //关闭流，请牢记
/**
*使用文件输入流构造一个对象输入流
*FileInputStream文件输入流
*ObjectInputStream对象输入流
*/
ObjectInputStream in = new ObjectInputStream(new
FileInputStream("employee.dat"));
///readObject()将对象从"employee.dat"中读出，需要类型转换
Employee[] newStaff = (Employee[])in.readObject();
in.close();
for (int i = 0; i < newStaff.length; i++)
System.out.println(newStaff[i]);
}
catch (Exception e)
{
e.printStackTrace();
}
}
}
///implements Serializable接口为标注该对象是可序列化的
class Employee implements Serializable
{
public Employee() {}
public Employee(String n, double s, int year, int month, int day)
{
name = n;
salary = s;
GregorianCalendar calendar =
new GregorianCalendar(year, month - 1, day);
hireDay = calendar.getTime();
}
public String getName()
{
return name;
}
public double getSalary()
{
return salary;
}
public Date getHireDay()
{
return hireDay;
}
public void raiseSalary(double byPercent)
{
double raise = salary * byPercent / 100;
salary += raise;
}
public String toString()
{
return getClass().getName()
+ "[name = "+ name
+ ",salary = "+ salary
+ ",hireDay = "+ hireDay
+ "]";
}
private String name;
private double salary;
private Date hireDay;
}
class Manager extends Employee
{
public Manager(String n, double s, int year, int month, int day)
{
super(n, s, year, month, day);
bonus = 0;
}
public double getSalary()
{
double baseSalary = super.getSalary();
return baseSalary + bonus;
}
public void setBonus(double b)
{
bonus = b;
}
public String toString()
{
return super.toString()
+ "[bonus = "+ bonus
+ "]";
}
private double bonus;
}
例子二：
//*********下面是序列化的代码*******
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.io.FileNotFoundException;
import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.io.IOException;
public class Test {
public static void main(String[] args)
{
Student[] student ={new Student( "student1 ",22, "男 "),
new Student( "student2 ",21, "女 "),
new Student( "student3 ",20, "男 "),
new Student( "student4 ",19, "女 "),
new Student( "student5 ",18, "男 "),
new Student( "student6 ",17, "男 "),
new Student( "student7 ",22, "女 "),
new Student( "student8 ",22, "女 "),
new Student( "student9 ",22, "女 "),
new Student( "student10 ",22, "男 "),};
try
{
//写入文件
ObjectOutputStream oos = new ObjectOutputStream(
new FileOutputStream( "haoguicai000.txt "));
oos.writeObject(student);//这里存的是数组对象，你也可以用循环把每一个Student对象写进去。
oos.close();
//从文件中读出对象
Student[] students2;
FileInputStream file = new FileInputStream( "haoguicai000.txt ");
ObjectInputStream ois = new ObjectInputStream(file);
students2 = (Student[])ois.readObject();
for(Student s :students2)
{
System.out.println( "姓名： "+s.getName());
System.out.println( "年龄： "+s.getAge());
System.out.println( "性别 "+s.getSex());
}
/*while(file.available()> 0)
System.out.println(((Student)ois.readObject()).getName()); 法二*/
ois.close();
file.close();
}
catch(FileNotFoundException ex)
{
ex.printStackTrace();
}
catch(IOException ex)
{
ex.printStackTrace();
}
catch(ClassNotFoundException ex)
{
ex.printStackTrace();
}
}
}
例三：
import java.awt.*;
import java.io.*;
import java.util.*;
import javax.swing.*;
class Student implements Serializable
{
int id;
String name;
int score;
Student(int id,String name,int score)
{
//创建一个学号为id,姓名为name，成绩为score的学生对象
setId(id);
setName(name);
setScore(score);
}
public void setId(int id)
{
this.id=id;
}
public int getId()
{
return this.id;
}
public void setName(String name)
{
this.name=name;
}
public String getName()
{
return name;
}
public void setScore(int score)
{
this.score=score;
}
public int getScore()
{
return score;
}
}
/*************************************/
public class ScoreSort
{
Scanner scanner;
Student[] student;
int number;
File filename;
public ScoreSort()
{
System.out.print("输入学生的个数：/n");
scanner=new Scanner(System.in);
number=scanner.nextInt();
try
{
if(number<=0) throw new NegativeException();
input(number);
writeToFile(student);
}
catch(NegativeException e)
{
JOptionPane.showMessageDialog(null,"人数小于1！");
}
}
public void input(int n)
{
student=new Student[n];
// System.out.println("学号 姓名 成绩");
for(int i=0;i<student.length;i++)
{ //输入学生的信息
int j = i+1;
System.out.println("输入第"+ j +"个学生");
System.out.println("学号");
int id=scanner.nextInt();
System.out.println("姓名");
String name=scanner.next();
System.out.println("成绩");
int score=scanner.nextInt();
System.out.println("___________________");
student[i]=new Student(id,name,score);
}
}
public void writeToFile(Student[] s)
{
try
{
ObjectOutputStream oos = new ObjectOutputStream(
new FileOutputStream( "student.dat "));
oos.writeObject(student);//这里存的是数组对象，你也可以用循环把每一个Student对象写进去。
oos.close();
}
catch(IOException ex)
{
System.out.println("写入文件失败！");
}
}
}
/***************************************************/
public class ScoreSort2
{
int number=100;
Student student[];
File filename;
public ScoreSort2()
{
output();
student=new Student[number]; //限定学生人数
student=readFromFile();
sort(student);
System.out.println("排序后:");
writeToFile(student);
output();
}
public void sort(Student s[])
{
Student temp = null;
for(int i=0;i<s.length;i++)
{
for(int j=0;j<s.length;j++)
{
if(s[j].getScore()<s[i].getScore())
{
temp = s[i];
s[i] = s[j];
s[j] = temp;
}
}
}
}
public Student[] readFromFile()
{
//将文件内容读入到数组并返回数组
Student[] s=null;
try
{
//从文件中读出对象
Student[] students2;
FileInputStream file = new FileInputStream( "student.dat ");
ObjectInputStream ois = new ObjectInputStream(file);
s = (Student[])ois.readObject();
System.out.println("i am well");
/*while(file.available()> 0)
* System.out.println(((Student)ois.readObject()).getName()); 法二*/
ois.close();
file.close();
}
catch(FileNotFoundException ex)
{
ex.printStackTrace();
}
catch(IOException ex)
{
ex.printStackTrace();
}
catch(ClassNotFoundException ex)
{
ex.printStackTrace();
}
return s;
}
public void writeToFile(Student[] s)
{ //将数组s写入到文件student.dat中
try
{
ObjectOutputStream output=new ObjectOutputStream(new FileOutputStream("student.dat"));
output.writeObject(s);
output.close();
}
catch(IOException ex)
{
JOptionPane.showMessageDialog(null,"写入文件失败！");
}
}
public void output()
{
Student[] s3=null;
try
{
ObjectInputStream input=new ObjectInputStream(new FileInputStream("student.dat"));
System.out.println("输出文件student.dat的内容：");
s3 = (Student[])input.readObject();
for(Student s :s3)
{
System.out.println( "学号： "+s.getId());
System.out.println( "姓名： "+s.getName());
System.out.println( "成绩 "+s.getScore());
}
input.close();
}
catch(IOException ex)
{
System.err.println("打开文件失败！");
}
catch(ClassNotFoundException ex)
{
System.err.println("ERROR");
}
}
}
/***************************/
class NegativeException extends Exception
{
NegativeException(){}
public String toString()
{
return "数字是小于或等于0";
}
}
/**********************************/
public class Test
{
public static void main(String[] args)
{
/*ScoreSort scoresort=new ScoreSort();
System.exit(0);*/
ScoreSort2 scoresort2=new ScoreSort2();
System.exit(0);
}
}
相关推荐
ObjectInputStream的用法---马克-to-win java视频的介绍对象输入字节流
在Java编程语言中，`ObjectInputStream`是用于反序列化对象的一个重要类，它属于Java的I/O流处理体系。序列化（Serialization）是将一个Java对象转换为字节流的过程，而反序列化（Deserialization）则是将字节流恢复...
4. **I/O流**：Java 7的`java.io`包中，流类如`FileInputStream`和`FileOutputStream`用于文件操作，`BufferedReader`和`PrintWriter`用于文本读写，`ObjectInputStream`和`ObjectOutputStream`则支持对象的序列化和...
- Java的I/O主要由`java.io`包中的类和接口实现，标准输入/输出处理由`java.lang`包中的类支持，但这些类都继承自`java.io`。 - 在JDK1.1之前，I/O流主要处理字节流，但JDK1.1之后引入了字符流（基于`Reader`和`...
1.java语言提供处理不同类型流的类的包是(D) a)java.sql b) java.util c) java.math d) java.io 2.不属于java.io包中的接口的一项是(C) a)DataInput b) DataOutput c) DataInputStream d) ObjectInput 3. ...
ObjectInputStream save = new ObjectInputStream(new FileInputStream( "savegly.txt")); gly = (Manager) save.readObject(); save.close(); /** * 创建系统菜单对像 */ Menu cx = new Menu()...
本练习旨在帮助初学者理解和掌握Java IO流的基础知识。 一、IO流的概念 IO流在Java中分为两大类：输入流（Input Stream）和输出流（Output Stream）。输入流用于从源（如文件、网络连接等）读取数据，而输出流则...
在文件操作方面，Java的File和FileInputStream/FileOutputStream类将被用来处理日记的保存和读取。日记内容可能以文本文件（如.txt或.rtf）的形式存储，或者使用ObjectOutputStream/ObjectInputStream进行序列化，...
- **抽象类与接口**：比较抽象类和接口的异同，阐述它们的应用场景。 #### 4. 异常处理 - **异常的概念**：理解异常的含义及其对程序执行的影响。 - **异常的分类**：区分编译时异常与运行时异常。 - **异常处理...
Java的FileInputStream、FileOutputStream和ObjectInputStream/ObjectOutputStream等类可以帮助理解文件操作。 8. **数据库连接**：可能使用JDBC（Java Database Connectivity）来与数据库交互，进行商品信息、订单...
《Java核心技术-卷1(基础知识-原书第10版)》是一本深入浅出的Java编程指南，专为Java编程爱好者和初学者设计。这本书详细介绍了Java语言的基础概念和核心特性，帮助读者掌握Java编程的基本技能。以下是该书涵盖的...
在Java中，可以使用ObjectOutputStream和ObjectInputStream类进行对象的序列化和反序列化。 7. **事件驱动编程**：Java GUI中的事件处理机制使得用户界面可以对用户的操作做出响应。例如，当用户点击“发送”按钮时...
- `ObjectInputStream` 和 `ObjectOutputStream` 支持序列化和反序列化 Java 对象。 - **字符流** - `InputStreamReader` 和 `OutputStreamWriter` 用于读写字符数据，通常与编码解码相关联。 - **随机存取文件*...
### Java标准类库（java基础类） #### 概述 Java标准类库是Java编程语言的核心组成部分之一，提供了丰富的API供开发者使用。本篇文档主要介绍`java.io`包下的核心概念及其应用，包括数据流处理、序列化、以及文件...
Java序列化和反序列化是Java虚拟机中的一种重要机制，它们可以将Java对象转换为二进制数据，然后将其保存到磁盘中或通过网络传输到其他机器上。今天，我们将深入理解Java虚拟机-Java内存区域透彻分析，探讨序列化和...
根据提供的文件信息，“动力节点Java基础301集”是一套非常全面的Java基础教程，旨在为初学者和有一定基础的学习者提供系统化的学习资源。接下来，我们将从以下几个方面对这套教程涉及的重要知识点进行总结： ### ...
1. **基础流与缓冲流**：Java的基础流包括字符流（Reader和Writer）和字节流（InputStream和OutputStream），它们直接处理原始的字节或字符。而缓冲流（BufferedReader、BufferedWriter、BufferedInputStream、...
Java语言程序设计的基础篇中，第十九章主要探讨了二进制输入/输出(I/O)的概念和使用。在Java中，I/O操作涉及到文件的读取和写入，这对于任何程序设计都至关重要。本章主要涵盖了以下几个核心知识点： 1. **Java中的...
Java提供了ObjectInputStream和ObjectOutputStream类，使得对象可以被转换为字节流在网络中传输，到达目的地后再还原。此外，JSON和XML等轻量级的数据交换格式也是常用的选择，它们便于解析，且跨平台性好。 安全性...
Java 反射机制是 Java 语言中的一种机制，允许在运行时检查和修改类的结构和行为。通过反射机制，我们可以在运行时获取类的信息，例如类的名称、方法、字段等，并可以动态地调用类的方法和访问类的字段。 反射机制...