一.Java序列化的作用

有的時候我們想要把一個Java物件變成位元組流的形式傳出去，有的時候我們想要從一個位元組流中恢復一個Java物件。例如，有的時候我們想要

把一個Java物件寫入到硬碟或者傳輸到網路上面的其它計算機，這時我們就需要自己去通過java把相應的物件寫成轉換成位元組流。對於這種通用

的操作，我們為什麼不使用統一的格式呢？沒錯，這裡就出現了java的序列化的概念。在Java的OutputStream類下面的子類ObjectOutput-

Stream類就有對應的WriteObject(Object object) 其中要求對應的object實現了java的序列化的介面。

為了更好的理解java序列化的應用，我舉兩個自己在開發專案中遇到的例子:

1)在使用tomcat開發JavaEE相關專案的時候，我們關閉tomcat後，相應的session中的物件就儲存在了硬碟上，如果我們想要在tomcat重啟的

時候能夠從tomcat上面讀取對應session中的內容，那麼儲存在session中的內容就必須實現相關的序列化操作。

2)如果我們使用的java物件要在分散式中使用或者在rmi遠端呼叫的網路中使用的話，那麼相關的物件必須實現java序列化介面。

親愛的小夥伴，大概你已經瞭解了java序列化相關的作用，接下來們來看看如何實現java的序列化吧。~

二.實現java物件的序列化和反序列化。

Java物件的序列化有兩種方式。

a.是相應的物件實現了序列化介面Serializable，這個使用的比較多，對於序列化介面Serializable介面是一個空的介面，它的主要作用就是

標識這個物件時可序列化的，jre物件在傳輸物件的時候會進行相關的封裝。這裡就不做過多的介紹了。

下面是一個實現序列化介面的Java序列化的例子:非常簡單

package com.shop.domain;

import java.util.Date;


public class Article implements java.io.Serializable {
    private static final
 
 long serialVersionUID = 1L;
    private Integer id; 
    private String title;  //文章標題
    private String content;  // 文章內容
    private String faceIcon;//表情圖示
    private Date postTime; //文章發表的時間
    private String ipAddr;  //使用者的ip

    private User author;  //回覆的使用者

    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getTitle() {
        return title;
    }
    public void setTitle(String title) {
        this.title = title;
    }
    public String getContent() {
        return content;
    }
    public void setContent(String content) {
        this.content = content;
    }
    public String getFaceIcon() {
        return faceIcon;
    }
    public void setFaceIcon(String faceIcon) {
        this.faceIcon = faceIcon;
    }
    public Date getPostTime() {
        return postTime;
    }
    public void setPostTime(Date postTime) {
        this.postTime = postTime;
    }
    public User getAuthor() {
        return author;
    }
    public void setAuthor(User author) {
        this.author = author;
    }
    public String getIpAddr() {
        return ipAddr;
    }
    public void setIpAddr(String ipAddr) {
        this.ipAddr = ipAddr;
    }


}

b.實現序列化的第二種方式為實現介面Externalizable，Externlizable的部分原始碼如下:

* @see java.io.ObjectInput
 * @see java.io.Serializable
 * @since   JDK1.1
 */
public interface Externalizable extends java.io.Serializable {
    /**
     * The object implements the writeExternal method to save its contents
     * by calling the methods of DataOutput for its primitive values or

沒錯，Externlizable介面繼承了java的序列化介面，並增加了兩個方法:

 - void writeExternal(ObjectOutput out) throws IOException;

 - void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;

首先，我們在序列化物件的時候，由於這個類實現了Externalizable 介面，在writeExternal()方法裡定義了哪些屬性可以序列化，

哪些不可以序列化，所以，物件在經過這裡就把規定能被序列化的序列化儲存檔案，不能序列化的不處理，然後在反序列的時候自動調

用readExternal()方法，根據序列順序挨個讀取進行反序列，並自動封裝成物件返回，然後在測試類接收，就完成了反序列。

所以說Exterinable的是Serializable的一個擴充套件。

為了更好的理解相關內容，請看下面的例子:

package com.xiaohao.test;

import java.io.Externalizable;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
import java.text.SimpleDateFormat;
import java.util.Date;


/**
 * 測試實體類
 * @author 小浩
 * @建立日期 2015-3-12
 */
class Person implements Externalizable{
        private static final long serialVersionUID = 1L;<br>    String userName;
    String password;
    String age;


    public Person(String userName, String password, String age) {
        super();
        this.userName = userName;
        this.password = password;
        this.age = age;
    }


    public Person() {
        super();
    }


    public String getAge() {
        return age;
    }
    public void setAge(String age) {
        this.age = age;
    }
    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }

    /**
     * 序列化操作的擴充套件類
     */
    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        //增加一個新的物件
        Date date=new Date();
        out.writeObject(userName);
        out.writeObject(password);
        out.writeObject(date);
    }

    /**
     * 反序列化的擴充套件類
     */
    @Override
    public void readExternal(ObjectInput in) throws IOException,
            ClassNotFoundException {
        //注意這裡的接受順序是有限制的哦，否則的話會出錯的
        // 例如上面先write的是A物件的話，那麼下面先接受的也一定是A物件...
        userName=(String) in.readObject();
        password=(String) in.readObject();
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
        Date date=(Date)in.readObject();       
        System.out.println("反序列化後的日期為:"+sdf.format(date));

    }
    @Override
    public String toString() {
        //注意這裡的年齡是不會被序列化的，所以在反序列化的時候是讀取不到資料的
        return "使用者名稱:"+userName+"密 碼:"+password+"年齡:"+age;
    }
}


/**
 * 序列化和反序列化的相關操作類
 * @author 小浩
 * @建立日期 2015-3-12   Java學習交流QQ群：589809992 我們一起學Java！
 */
class Operate{
    /**
     * 序列化方法
     * @throws IOException
     * @throws FileNotFoundException
     */
    public void serializable(Person person) throws FileNotFoundException, IOException{
        ObjectOutputStream outputStream=new ObjectOutputStream(new FileOutputStream("a.txt"));
        outputStream.writeObject(person);      
    }

    /**
     * 反序列化的方法
     * @throws IOException
     * @throws FileNotFoundException
     * @throws ClassNotFoundException
     */
    public Person deSerializable() throws FileNotFoundException, IOException, ClassNotFoundException{
        ObjectInputStream ois=new ObjectInputStream(new FileInputStream("a.txt"));
        return (Person) ois.readObject();
    }



}
/**
 * 測試實體主類
 * @author 小浩
 * @建立日期 2015-3-12
 */
public class Test{
    public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
       Operate operate=new Operate();
       Person person=new Person("小浩","123456","20");
       System.out.println("為序列化之前的相關資料如下:\n"+person.toString());
       operate.serializable(person);
       Person newPerson=operate.deSerializable();
       System.out.println("-------------------------------------------------------");
       System.out.println("序列化之後的相關資料如下:\n"+newPerson.toString());
    }


}

首先，我們在序列化UserInfo物件的時候，由於這個類實現了Externalizable 介面，在writeExternal()方法裡定義了哪些屬性可

以序列化，哪些不可以序列化，所以，物件在經過這裡就把規定能被序列化的序列化儲存檔案，不能序列化的不處理，然後在反序列

的時候自動呼叫readExternal()方法，根據序列順序挨個讀取進行反序列，並自動封裝成物件返回，然後在測試類接收，就完成了反

序列。

對於實現Java的序列化介面需要注意一下幾點:

1.java中的序列化時transient變數(這個關鍵字的作用就是告知JAVA我不可以被序列化)和靜態變數不會被序列化(下面是一個測試的例子)

import java.io.*;

class Student1 implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    private transient String password;
    private static int count = 0;

    public Student1(String name, String password) {
        System.out.println("呼叫Student的帶參的構造方法");
        this.name = name;
        this.password = password;
        count++;
    }

    public String toString() {
        return "人數: " + count + " 姓名: " + name + " 密碼: " + password;
    }
}

public class ObjectSerTest1 {
    public static void main(String args[]) {
        try {
            FileOutputStream fos = new FileOutputStream("test.obj");
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            Student1 s1 = new Student1("張三", "12345");
            Student1 s2 = new Student1("王五", "54321");
            oos.writeObject(s1);
            oos.writeObject(s2);
            oos.close();
            FileInputStream fis = new FileInputStream("test.obj");
            ObjectInputStream ois = new ObjectInputStream(fis);
            Student1 s3 = (Student1) ois.readObject();
            Student1 s4 = (Student1) ois.readObject();
            System.out.println(s3);
            System.out.println(s4);
            ois.close();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e1) {
            e1.printStackTrace();
        }
    }
}

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
/**
 * Java學習交流QQ群：589809992 我們一起學Java！
 */ 
public class Test{



    public static void main(String args[]){

        try {

            FileInputStream fis = new FileInputStream("test.obj");
            ObjectInputStream ois = new ObjectInputStream(fis);

            Student1 s3 = (Student1) ois.readObject();
            Student1 s4 = (Student1) ois.readObject();

            System.out.println(s3);
            System.out.println(s4);

            ois.close();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e1) {
            e1.printStackTrace();
        }
    }



}

2.也是最應該注意的，如果你先序列化物件A後序列化B，那麼在反序列化的時候一定記著JAVA規定先讀到的物件是先被序列化的物件，不要先接收物件B，那樣會報錯.尤其在使用上面的Externalizable的時候一定要注意讀取的先後順序。

3.實現序列化介面的物件並不強制宣告唯一的serialVersionUID，是否宣告serialVersionUID對於物件序列化的向上向下的相容性有很大的影響。我們來做個測試：

思路一 
把User中的serialVersionUID去掉，序列化儲存。反序列化的時候，增加或減少個欄位，看是否成功。 
Java程式碼

public class User implements Serializable{

private String name;

 private int age;

private long phone;

private List<UserVo> friends;

...<br>}

儲存到檔案中： 
Java程式碼

ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream os = new ObjectOutputStream(bos);
os.writeObject(src);
os.flush();
os.close();
byte[] b = bos.toByteArray();
bos.close();
FileOutputStream fos = new FileOutputStream(dataFile);
fos.write(b);
fos.close();

增加或者減少欄位後，從檔案中讀出來，反序列化： 
Java程式碼

ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream os = new ObjectOutputStream(bos);
os.writeObject(src);
os.flush();
os.close();
byte[] b = bos.toByteArray();
bos.close();
FileOutputStream fos = new FileOutputStream(dataFile);
fos.write(b);
fos.close();

結果：丟擲異常資訊 
Java程式碼

Exception in thread "main" java.io.InvalidClassException: serialize.obj.UserVo; local class incompatible: stream classdesc serialVersionUID = 3305402508581390189, local class serialVersionUID = 7174371419787432394 at java.io.ObjectStreamClass.initNonProxy(ObjectStreamClass.java:560)
at java.io.ObjectInputStream.readNonProxyDesc(ObjectInputStream.java:1582)
at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1495)
at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1731)
at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1328)
at java.io.ObjectInputStream.readObject(ObjectInputStream.java:350)
at serialize.obj.ObjectSerialize.read(ObjectSerialize.java:74)
at serialize.obj.ObjectSerialize.main(ObjectSerialize.java:27)

思路二 
eclipse指定生成一個serialVersionUID，序列化儲存，修改欄位後反序列化 
略去程式碼 
結果：反序列化成功 
結論 
如果沒有明確指定serialVersionUID，序列化的時候會根據欄位和特定的演算法生成一個serialVersionUID，當屬性有變化時這個id發生了變化，所以反序列化的時候 
就會失敗。丟擲“本地classd的唯一id和流中class的唯一id不匹配”。 
jdk文件關於serialVersionUID的描述： 
寫道

如果可序列化類未顯式宣告 serialVersionUID，則序列化執行時將基於該類的各個方面計算該類的預設 serialVersionUID 值，如“Java(TM) 物件序列化規範”中所述。不過，強烈建議 所有可序列化類都顯式宣告 serialVersionUID 值，原因是計算預設的 serialVersionUID 對類的詳細資訊具有較高的敏感性，根據編譯器實現的不同可能千差萬別，這樣在反序列化過程中可能會導致意外的 InvalidClassException。因此，為保證 serialVersionUID 值跨不同 java 編譯器實現的一致性，序列化類必須宣告一個明確的 serialVersionUID 值。還強烈建議使用 private 修飾符顯示宣告 serialVersionUID（如果可能），原因是這種宣告僅應用於直接宣告類 – serialVersionUID 欄位作為繼承成員沒有用處。陣列類不能宣告一個明確的 serialVersionUID，因此它們總是具有預設的計算值，但是陣列類沒有匹配 serialVersionUID 值的要求。

三.實現序列化的其它方式 (這是一個擴充套件內容，感興趣的可以擴充套件一下)

1)是把物件包裝成JSON字串傳輸。

這裡採用JSON格式同時使用採用Google的gson-2.2.2.jar 進行轉義

2)採用谷歌的ProtoBuf

隨著Google工具protoBuf的開源，protobuf也是個不錯的選擇。對JSON,Object Serialize(Java的序列化和反序列化),ProtoBuf 做個對比。 
定義一個通用的待傳輸的物件UserVo：

/**
 * Java學習交流QQ群：589809992 我們一起學Java！
 */
public class User
private static final long serialVersionUID = -5726374138698742258L;
{ private String name;
  private int age;
  private long phone;
  private List<User> friends;
 ...set和get方法
 }

初始化User的例項src： 
Java程式碼

User user1 = new UserVo();
user1 .setName("user1 ");
 user1 .setAge(30);
 user1 .setPhone(13789126278L);
 UserVo f1 = new UserVo();
 f1.setName("tmac");
 f1.setAge(32);
 f1.setPhone(123L);
 User user2 = new User();
 user2 .setName("user2 ");
 user2 .setAge(29);
 user2 .setPhone(123L); <br> List<User> friends = new ArrayList<User>();
 friends.add(user1 );
 friends.add(user2 );
 user1 .setFriends(friends);

1.首先使用JOSN來實現序列化。

Java程式碼

Gson gson = new Gson();<br>String json = gson.toJson(src);

得到的字串： 
Js程式碼

{"name":"user1 ","age":30,"phone":123,"friends":[{"name":"user1 ","age":32,"phone":123},{"name":"user2 ","age":29,"phone":123}]}

位元組數為153 
Json的優點：明文結構一目瞭然，可以跨語言，屬性的增加減少對解析端影響較小。缺點：位元組數過多，依賴於不同的第三方類庫。

Object Serialize（Java的序列化和反序列化） 
UserVo實現Serializalbe介面，提供唯一的版本號： 
序列化方法：

Java程式碼

ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream os = new ObjectOutputStream(bos);
os.writeObject(src);
os.flush();
os.close();
byte[] b = bos.toByteArray();
bos.close();

位元組數是238

反序列化： 
Java程式碼

ObjectInputStream ois = new ObjectInputStream(fis);
vo = (UserVo) ois.readObject();
ois.close();
fis.close();

Object Serializalbe 優點：java原生支援，不需要提供第三方的類庫，使用比較簡單。 
缺點：無法跨語言，位元組數佔用比較大，某些情況下對於物件屬性的變化比較敏感。 
物件在進行序列化和反序列化的時候，必須實現Serializable介面，但並不強制宣告唯一的serialVersionUID 
是否宣告serialVersionUID對於物件序列化的向上向下的相容性有很大的影響。

Google ProtoBuf 
protocol buffers 是google內部得一種傳輸協議，目前專案已經開源（http://code.google.com/p/protobuf/）。 
它定義了一種緊湊得可擴充套件得二進位制協議格式，適合網路傳輸，並且針對多個語言有不同得版本可供選擇。 
以protobuf-2.5.0rc1為例，準備工作： 
下載原始碼，解壓，編譯，安裝 
Shell程式碼

tar zxvf protobuf-2.5.0rc1.tar.gz ./configure ./make ./make install

測試： 
Shell程式碼

MacBook-Air:~ ming$ protoc --version libprotoc 2.5.0

安裝成功！ 
進入原始碼得java目錄，用mvn工具編譯生成所需得jar包，protobuf-java-2.5.0rc1.jar

1、編寫.proto檔案，命名UserVo.proto

Text程式碼

package serialize;
option java_package = "serialize";
option java_outer_classname="UserVoProtos";
message User{
optional string name = 1;
optional int32 age = 2;
optional int64 phone = 3;
repeated serialize.UserVo friends = 4;

}

2、在命令列利用protoc 工具生成builder類 
Shell程式碼 
protoc -IPATH=.proto檔案所在得目錄 –java_out=java檔案的輸出路徑 .proto的名稱 
得到UserProtos類

3、編寫序列化程式碼 
Java程式碼

UserVoProtos.User.Builder builder = UserVoProtos.User.newBuilder();
builder.setName("Yaoming"); builder.setAge(30);
builder.setPhone(13789878978L);
UserVoProtos.UserVo.Builder builder1 = UserVoProtos.UserVo.newBuilder();
builder1.setName("tmac"); builder1.setAge(32); builder1.setPhone(138999898989L);
UserVoProtos.UserVo.Builder builder2 = UserVoProtos.UserVo.newBuilder();
builder2.setName("liuwei"); builder2.setAge(29); builder2.setPhone(138999899989L);
builder.addFriends(builder1);
builder.addFriends(builder2);
UserVoProtos.UserVo vo = builder.build();  byte[] v = vo.toByteArray();

位元組數53 
反序列化 
Java程式碼

UserVoProtos
            
  
           

              
              
            
            
相關推薦
			   
            
            
            
 

    

    
    
Spark SQL初始化和創建DataFrame的幾種方式
     
 hdf   per   ()   med   分析   exception   vat   都是   tty   一、前述
      1、SparkSQL介紹
          Hive是Shark的前身，Shark是SparkSQL的前身,SparkSQL產生的根本原因是其完全脫離了Hive的限制。

 

  
 

    

    
    
java序列化和反序列化得幾種方式
     
 
                

一.Java序列化的作用

有的時候我們想要把一個Java物件變成位元組流的形式傳出去，有的時候我們想要從一個位元組流中恢復一個Java物件。例如，有的時候我們想要

把一個Java物件寫入到硬碟或者傳輸到網路上面的其它計算機，這時我們就需要自己去通過java把相應的物件 

  
 

    

    
    
java中什麽是序列化和反序列化
     
 zab   question   .com   程序   還原   破壞   ans   但我   實現   
序列化:能夠把一個對象用二進制的表示出來。             類似我第一個字節表示什麽屬性名詞，第二個字節表示什麽屬性值，第幾個字段表示有幾個屬性等。        而且這個二進制可以寫到硬 

  
 

    

    
    
java中的序列化和反序列化學習筆記
     
 文件   track   反序列化   out   val   nts   鼠標   main   version   

須要序列化的Person類：
package cn.itcast_07;

import java.io.Serializable;

/*
 * NotSerializableE 

  
 

    

    
    
java對象的序列化和反序列化
     
 底層   修飾   我們   puts   nbsp   tostring   read   one   asics   一，對象的序列化，反序列化1.對象的序列化，就是將Object轉換成byte序列，反之叫對象的反序列化2.做序列化需要有流類，序列化流(ObjectOutputStream),是(字節的) 

  
 

    

    
    
java基礎序--列化和反序列化
     
 color   tran   public   png   gin   jdk   style   硬盤   brush   一、什麽是序列化和反序列化:
　　序列化：是指把java堆內存中的對象轉換成字節（二進制流）的過程。也就是通過某種方式將java對象存儲在磁盤內存中，這個過程稱為序列化
　　反序列化： 

  
 

    

    
    
2018-07-25期 Java序列化和反序列化編程小案例
     
 測試   product   set   pri   get   sof   serial   span   not   package cn.sjq.Serializable.java;import java.io.FileInputStream;import java.io.FileOutputStrea 

  
 

    

    
    
Java 之 Serializable 序列化和反序列化的概念,作用的通俗易懂的解釋
     
 計算   transient   全部   序列化對象   語義   meta   person   int   較高的   遇到這個 Java Serializable 序列化這個接口，我們可能會有如下的問題a，什麽叫序列化和反序列化b，作用。為啥要實現這個 Serializable 接口，也就是為啥要序列 

  
 

    

    
    
Java-裝飾流-物件流 - 序列化和反序列化
     
  
  
  
 ObjectInputStream(反序列化) & ObjectOutputStream（序列化） 
 1.先寫出後讀取 2.讀取的順序必須保持一致 3.不是所有的物件都能序列化，要加上serializable接口才行 
 當不想對物件中的某個屬性序列化時，在屬性中新增transie 

  
 

    

    
    
java序列化和反序列化物件
     
  
 
 
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

impo 

  
 

    

    
    
Java 之 Serializable 序列化和反序列化的概念 通俗易懂！！！
     
  
  
  
 轉自： https://blog.csdn.net/qq_27093465/article/details/78544505 
 遇到這個 Java Serializable 序列化這個介面，我們可能會有如下的問題a，什麼叫序列化和反序列化 b，作用。為啥要實現這個 Serializable 

  
 

    

    
    
Java中使用FastJSON進行物件的序列化和反序列化
     
 Java中使用FastJSON進行物件的序列化和反序列化 
1.新增依賴，maven的pom.xml檔案中新增以下依賴 
<dependency>
            <groupId>com.alibaba</groupId>
            <arti 

  
 

    

    
    
記一次使用Jackson對Java物件序列化和反序列化的踩坑經歷
     
  
 
 背景大概是這樣，專案中的兩個服務A和B依賴了同一個common包的Java類，A對該類json序列化，而B對其反序列化。在一次common包升級過程中，這個Java類中增加了一個屬性，由於B其實用不到這個屬性，就只把A給升級打包了，這就導致B在反序列化時出現了一個異常：com.fasterxml.j 

  
 

    

    
    
Think In Java——序列化和反序列化
     
 
                1）Java中的Serializable介面和Externalizable介面有什麼區別？

這個是面試中關於Java序列化問的最多的問題。我的回答是，Externalizable介面提供了兩個方法writeExternal()和readExternal()。這兩個方法給我們 

  
 

    

    
    
java物件的序列化和反序列化
     
 引言：
　　序列化是將物件的狀態資訊轉換為可以儲存或傳輸的形式的過程，在序列化期間，物件將其帶你過去的狀態寫入到臨時或持儲存區，反序列化就是重新建立物件的過程，此物件來自於臨時或持久儲存區。
序列化的作用：
　　就好比如儲存資料到資料庫，將一些資料持久化到資料庫中，而有時候需要將物件持久化，雖然說將物件狀態持 

  
 

    

    
    
【修真院java小課堂】什麼是序列化和反序列化，在RMI中是否要實現 SERIALIZABLE 介面， SERIALVERSIONUID的用處是什麼？
     
 
            8.更多討論
                 1、serialVersionUID實際作用
     假設本地資料庫中儲存了大量的user物件，後來由於需求，要修改User類中的屬性；如果不設定SerialVersionUID，根據屬性方法等自動生成，就會出現程式碼演示中的錯誤，造 

  
 

    

    
    
Java序列化和反序列化存在的意義
     
 
							
							
							文章來源:

一 javabean為什麼要實現序列化?
所謂的Serializable,就是java提供的通用資料儲存和讀取的介面。至於從什麼地方讀出來和儲存到哪裡去都被隱藏在函式引數的背後了。這樣子，任何型別只要實現了Serializable介面，就可以被儲存 

  
 

    

    
    
在Java中進行序列化和反序列化
     
 
							
							
							
物件序列化的目標是將物件儲存在磁碟中，或者允許在網路中直接傳輸物件。

    物件序列化允許把記憶體中的Java物件轉換成平臺無關的二進位制流，從而允許把這種二進位制流持久儲存在磁碟上或者通過網路將這種二進位制流傳輸到另外一個網路節點。
    其他程式一旦 

  
 

    

    
    
《程式設計師程式碼面試指南》二叉樹的序列化和反序列化——java實現
     
 
							
							
							二叉樹的序列化和反序列化
題目描述：
二叉樹被記錄成檔案的過程叫作二叉樹的序列化，通過檔案內容重建原來二叉樹的過程叫作二叉樹的反序列化。
給定一棵二叉樹的頭節點head，並已知二叉樹節點值的型別為32位整型。請設計一種二叉樹序列化和反序列化的方案，並用程式碼實現 

  
 

    

    
    
java的序列化和反序列化
     
 
                java提供了兩種物件持久化的方式,分別是序列化和反序列化

序列化

當進行遠端通訊時,無論是何種型別的資料,都會以二進位制的形式在網路上傳輸.序列化是將物件描述為一連串位元組的過程,用來解決物件流的讀寫問題.序列化可以將物件的狀態寫在流裡進行網路傳輸,或者儲存在檔案.資料