java IO(三)：数据操作流、对象序列化、压缩流

最新推荐文章于 2020-02-05 11:41:13 发布

渔歌向晚

最新推荐文章于 2020-02-05 11:41:13 发布

阅读量1.8k

点赞数

文章标签： java

本文链接：https://blog.csdn.net/Troy__/article/details/25056085

版权

数据操作流

在io包中，提供了两个与平台无关的数据操作流：

数据输入流(DataInputStream)
数据输出流(DataOutputStream)

通常数据输出流会按一定格式将数据输出，再通过数据输入流按照一定格式将数据读入

DataOutputStream接口定义了一系列的writeXxx()的操作，可以写入各种数据类型的数据。

范例：使用数据操作流写入与读出数据

import java.io.DataOutputStream ;
import java.io.File ;
import java.io.FileOutputStream ;
public class DataOutputStreamDemo{
	public static void main(String args[]) throws Exception{	// 所有异常抛出
		DataOutputStream dos = null ;			// 声明数据输出流对象
		File f = new File("d:" + File.separator + "order.txt") ; // 文件的保存路径
		dos = new DataOutputStream(new FileOutputStream(f)) ;	// 实例化数据输出流对象
		String names[] = {"衬衣","手套","围巾"} ;	// 商品名称
		float prices[] = {98.3f,30.3f,50.5f} ;		// 商品价格
		int nums[] = {3,2,1} ;	// 商品数量
		for(int i=0;i<names.length;i++){	// 循环输出
			dos.writeChars(names[i]) ;	// 写入字符串
			dos.writeChar('\t') ;	// 写入分隔符
			dos.writeFloat(prices[i]) ; // 写入价格
			dos.writeChar('\t') ;	// 写入分隔符
			dos.writeInt(nums[i]) ; // 写入数量
			dos.writeChar('\n') ;	// 换行
		}
		dos.close() ;	// 关闭输出流
	}
};

import java.io.DataInputStream ;
import java.io.File ;
import java.io.FileInputStream ;
public class DataInputStreamDemo{
	public static void main(String args[]) throws Exception{	// 所有异常抛出
		DataInputStream dis = null ;		// 声明数据输入流对象
		File f = new File("d:" + File.separator + "order.txt") ; // 文件的保存路径
		dis = new DataInputStream(new FileInputStream(f)) ;	// 实例化数据输入流对象
		String name = null ;	// 接收名称
		float price = 0.0f ;	// 接收价格
		int num = 0 ;	// 接收数量
		char temp[] = null ;	// 接收商品名称
		int len = 0 ;	// 保存读取数据的个数
		char c = 0 ;	// '\u0000'
		try{
			while(true){
				temp = new char[200] ;	// 开辟空间
				len = 0 ;
				while((c=dis.readChar())!='\t'){	// 接收内容
					temp[len] = c ;
					len ++ ;	// 读取长度加1
				}
				name = new String(temp,0,len) ;	// 将字符数组变为String
				price = dis.readFloat() ;	// 读取价格
				dis.readChar() ;	// 读取\t
				num = dis.readInt() ;	// 读取int
				dis.readChar() ;	// 读取\n
				System.out.printf("名称：%s；价格：%5.2f；数量：%d\n",name,price,num) ;
			}
		}catch(Exception e){}
		dis.close() ;
	}
};

对象序列化

对象序列化就是把对象变为二进制数据流的一种方法，通过对象的序列化可以方便的实现对象的传输或储存。

如果一个类想支持初始化，则该类必须实现java.io.Serilizable接口。该接口定义如下：

publicinterface Serilizable{ }

该接口中不存在方法，因此该类属于一个标示接口，表示实现该的接口的类具备某种能力。

1. 对象的序列化与反序列化

2. serialVersionUID

在序列化的操作中引入了一个serialVersionUID常量，可以通过此常量来验证版本的一致性，在进行反序列化的时候，JVM会把传进来的字节流中的serialVersionUID与本地对应类的serialVersionUID进行比较，如果相同就认为是一致的，可以进行反序列化，否则就会出现序列化版本不一致的异常。

import java.io.Serializable ;
public class Person implementsSerializable{
         private String name ;       // 声明name属性，但是此属性不被序列化
         private int age ;                 // 声明age属性
         publicPerson(String name,int age){         // 通过构造设置内容
                   this.name= name ;
                   this.age= age ;
         }
         publicString toString(){    // 覆写toString()方法
                   return"姓名：" + this.name + "；年龄：" + this.age;
         }
};

3. 对象输出流：ObjectOutputStream

一个对象要想进行输出，就必须使用ObjectOutputStream类，该类定义如下

如果一个对象中的某个属性不希望被序列化的话，则可以使用transient关键字进行声明。

importjava.io.File ;
importjava.io.FileOutputStream ;
importjava.io.OutputStream ;
importjava.io.ObjectOutputStream ;
publicclass SerDemo01{
public static void main(String args[]) throwsException {
           File f = new File("D:" +File.separator + "test.txt") ;        //定义保存路径
           ObjectOutputStream oos = null ;     // 声明对象输出流
           OutputStream out = newFileOutputStream(f) ;      // 文件输出流
           oos = new ObjectOutputStream(out) ;
           oos.writeObject(new Person("张三",30));     // 保存对象
           oos.close() ;     // 关闭
}
};

4. 对象输入流：ObjectInputStream

importjava.io.File ;
importjava.io.FileInputStream ;
importjava.io.InputStream ;
importjava.io.ObjectInputStream ;
publicclass SerDemo02{
public static void main(String args[]) throwsException {
           File f = new File("D:" +File.separator + "test.txt") ;        //定义保存路径
           ObjectInputStream ois = null ;          // 声明对象输入流
           InputStream input = newFileInputStream(f) ;         // 文件输入流
           ois = new ObjectInputStream(input) ;     // 实例化对象输入流
           Object obj = ois.readObject() ;         // 读取对象
           ois.close() ;       // 关闭
           System.out.println(obj) ;
}
};

6. 序列化一组对象

对象输出时只提供了一个对象的输出操作(writeObject(Object obj))，并没有提供多个对象的输出，如果现在要对多个对象进行序列化的操作，则可以使用对象数组完成，由于数组是引用数据类型，所以可以直接使用Object类型进行接收。

importjava.io.File ;
importjava.io.IOException ;
importjava.io.FileOutputStream ;
importjava.io.OutputStream ;
importjava.io.ObjectOutputStream ;
importjava.io.FileInputStream ;
importjava.io.InputStream ;
importjava.io.ObjectInputStream ;
publicclass SerDemo05{
public static void main(String args[]) throwsException{
           Person per[] = {new Person("张三",30),newPerson("李四",31),
                    new Person("王五",32)};
           ser(per) ;
           Object o[] = (Object[])dser() ;
           for(int i=0;i<o.length;i++){
                    Person p = (Person)o[i] ;
                    System.out.println(p) ;
           }
}
public static void ser(Object obj[]) throwsException {
           File f = new File("D:" +File.separator + "test.txt") ;        //定义保存路径
           ObjectOutputStream oos = null ;     // 声明对象输出流
           OutputStream out = new FileOutputStream(f);      // 文件输出流
           oos = new ObjectOutputStream(out) ;
           oos.writeObject(obj) ;      // 保存对象
           oos.close() ;     // 关闭
}
public static Object[] dser() throws Exception{
           File f = new File("D:" +File.separator + "test.txt") ;        //定义保存路径
           ObjectInputStream ois = null ;          // 声明对象输入流
           InputStream input = newFileInputStream(f) ;         // 文件输入流
           ois = new ObjectInputStream(input) ;     // 实例化对象输入流
           Object obj[] =(Object[])ois.readObject() ;        // 读取对象
           ois.close() ;       // 关闭
           return obj ;
}
};

数组能储存的对象数量有限，因此可以使用类集进行序列化的操作。

压缩流

在Java中为了减少传输时的数据量也专门提供了压缩流，可以将文件或者文件夹压缩成ZIP、JAR、GZIP等格式。