java IO数据操作流、对象序列化、压缩流代码解析

数据操作流

在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接口。该接口定义如下：

publicinterfaceserilizable{}

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

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(objectobj))，并没有提供多个对象的输出，如果现在要对多个对象进行序列化的操作，则可以使用对象数组完成，由于数组是引用数据类型，所以可以直接使用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等格式。

该流使用较少，因此只做简要介绍。

总结

以上就是本文关于java io数据操作流、对象序列化、压缩流代码解析的全部内容，希望对大家有所帮助。感兴趣的朋友可以继续参阅本站其他相关专题，如有不足之处，欢迎留言指出。感谢朋友们对本站的支持！