java方法序列化

Ⅰ 什麼是java序列化，如何實現java序列化

1. 序列化的定義：任何數據都是以二進制的形式存貯到硬碟或是在網路上傳送，而Java為了能將Java對象存貯到硬碟上或在網路上傳送，把Java對象轉換成位元組流進行傳輸，這個轉換過程就稱之為Java序列化。

2. Java序列化實現方式：如果需要將一個Java類序列化，這個Java類必須實現Serializable介面，這個介面中並沒有需要實現的方法，只是標注這個類的對象可以被序列化。
   

Ⅱ 什麼是java的序列化jdk如何實現java序列化

Java序列化與反序列化是什麼？為什麼需要序列化與反序列化？如何實現Java序列化與反序列化？本文圍繞這些問題進行了探討。
1.Java序列化與反序列化

Java序列化是指把Java對象轉換為位元組序列的過程；而Java反序列化是指把位元組序列恢復為Java對象的過程。

2.為什麼需要序列化與反序列化

我們知道，當兩個進程進行遠程通信時，可以相互發送各種類型的數據，包括文本、圖片、音頻、視頻等， 而這些數據都會以二進制序列的形式在網路上
傳送。那麼當兩個Java進程進行通信時，能否實現進程間的對象傳送呢？答案是可以的。如何做到呢？這就需要Java序列化與反序列化了。換句話說，一方
面，發送方需要把這個Java對象轉換為位元組序列，然後在網路上傳送；另一方面，接收方需要從位元組序列中恢復出Java對象。

當我們明晰了為什麼需要Java序列化和反序列化後，我們很自然地會想Java序列化的好處。其好處一是實現了數據的持久化，通過序列化可以把數據永久地保存到硬碟上（通常存放在文件里），二是，利用序列化實現遠程通信，即在網路上傳送對象的位元組序列。

3.如何實現Java序列化與反序列化

1）JDK類庫中序列化API

java.io.ObjectOutputStream：表示對象輸出流

它的writeObject(Object obj)方法可以對參數指定的obj對象進行序列化，把得到的位元組序列寫到一個目標輸出流中。

java.io.ObjectInputStream：表示對象輸入流

它的readObject()方法源輸入流中讀取位元組序列，再把它們反序列化成為一個對象，並將其返回。

2）實現序列化的要求

只有實現了Serializable或Externalizable介面的類的對象才能被序列化，否則拋出異常。

3）實現Java對象序列化與反序列化的方法

假定一個Student類，它的對象需要序列化，可以有如下三種方法：

方法一：若Student類僅僅實現了Serializable介面，則可以按照以下方式進行序列化和反序列化

ObjectOutputStream採用默認的序列化方式，對Student對象的非transient的實例變數進行序列化。

ObjcetInputStream採用默認的反序列化方式，對對Student對象的非transient的實例變數進行反序列化。

方法二：若Student類僅僅實現了Serializable介面，並且還定義了readObject(ObjectInputStream in)和writeObject(ObjectOutputSteam out)，則採用以下方式進行序列化與反序列化。

ObjectOutputStream調用Student對象的writeObject(ObjectOutputStream out)的方法進行序列化。

ObjectInputStream會調用Student對象的readObject(ObjectInputStream in)的方法進行反序列化。

方法三：若Student類實現了Externalnalizable介面，且Student類必須實現readExternal(ObjectInput in)和writeExternal(ObjectOutput out)方法，則按照以下方式進行序列化與反序列化。

ObjectOutputStream調用Student對象的writeExternal(ObjectOutput out))的方法進行序列化。

ObjectInputStream會調用Student對象的readExternal(ObjectInput in)的方法進行反序列化。

4）JDK類庫中序列化的步驟

步驟一：創建一個對象輸出流，它可以包裝一個其它類型的目標輸出流，如文件輸出流：

ObjectOutputStream out = new ObjectOutputStream(new fileOutputStream(「D:\\objectfile.obj」));

步驟二：通過對象輸出流的writeObject()方法寫對象：

out.writeObject(「Hello」);

out.writeObject(new Date());

5）JDK類庫中反序列化的步驟

步驟一：創建一個對象輸入流，它可以包裝一個其它類型輸入流，如文件輸入流：

ObjectInputStream in = new ObjectInputStream(new fileInputStream(「D:\\objectfile.obj」));

步驟二：通過對象輸出流的readObject()方法讀取對象：

String obj1 = (String)in.readObject();

Date obj2 = (Date)in.readObject();

說明：為了正確讀取數據，完成反序列化，必須保證向對象輸出流寫對象的順序與從對象輸入流中讀對象的順序一致。

為了更好地理解Java序列化與反序列化，選擇方法一編碼實現。

Student類定義如下：

[java] view plain
package com.jieke.io;
import java.io.Serializable;

/**
*Title:學生類
*Description:實現序列化介面的學生類
*Copyright: right(c) 2012
*Filename: Student.java
*@author Wang Luqing
*@version 1.0
*/
public class Student implements Serializable
{
private String name;
private char sex;
private int year;
private double gpa;

public Student()
{

}
public Student(String name,char sex,int year,double gpa)
{
this.name = name;
this.sex = sex;
this.year = year;
this.gpa = gpa;
}

public void setName(String name)
{
this.name = name;
}

public void setSex(char sex)
{
this.sex = sex;
}

public void setYear(int year)
{
this.year = year;
}

public void setGpa(double gpa)
{
this.gpa = gpa;
}

public String getName()
{
return this.name;
}

public char getSex()
{
return this.sex;
}

public int getYear()
{
return this.year;
}

public double getGpa()
{
return this.gpa;
}
}

把Student類的對象序列化到文件O:\\Java\\com\\jieke\\io\\student.txt，並從該文件中反序列化，向console顯示結果。代碼如下：

[java] view plain
import java.io.*;

/**
*Title:應用學生類
*Description:實現學生類實例的序列化與反序列化
*Copyright: right(c) 2012
*Filename: UseStudent.java
*@author Wang Luqing
*@version 1.0
*/

public class UseStudent
{
public static void main(String[] args)
{
Student st = new Student("Tom",'M',20,3.6);
File file = new File("O:\\Java\\com\\jieke\\io\\student.txt");
try
{
file.createNewFile();
}
catch(IOException e)
{
e.printStackTrace();
}
try
{
//Student對象序列化過程
FileOutputStream fos = new FileOutputStream(file);
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(st);
oos.flush();
oos.close();
fos.close();

//Student對象反序列化過程
FileInputStream fis = new FileInputStream(file);
ObjectInputStream ois = new ObjectInputStream(fis);
Student st1 = (Student) ois.readObject();
System.out.println("name = " + st1.getName());
System.out.println("sex = " + st1.getSex());
System.out.println("year = " + st1.getYear());
System.out.println("gpa = " + st1.getGpa());
ois.close();
fis.close();
}
catch(ClassNotFoundException e)
{
e.printStackTrace();
}
catch (IOException e)
{
e.printStackTrace();
}
}
}

結果如下所示：

name = Tom

sex = M

year = 20

gpa = 3.6

總結：

1）Java序列化就是把對象轉換成位元組序列，而Java反序列化就是把位元組序列還原成Java對象。
2）採用Java序列化與反序列化技術，一是可以實現數據的持久化，在MVC模式中很是有用；二是可以對象數據的遠程通信。

Ⅲ Java序列化，如何實現

DK類庫中序列化的步驟
步驟一：創建一個對象輸出流，它可以包裝一個其它類型的目標輸出流，如文件輸出流：
ObjectOutputStream out = new ObjectOutputStream(new fileOutputStream(「D:\\objectfile.obj」));
步驟二：通過對象輸出流的writeObject()方法寫對象：
out.writeObject(「Hello」);
out.writeObject(new Date());

Ⅳ 什麼是java序列化，如何實現java序列化

序 列 化: 指把堆內存中的Java對象數據,通過某種方式把對象存儲到磁碟文件中或者傳遞給其他網路的節點(在網路上傳輸).我們把這個過程稱之為序列化.

反序列化:把磁碟文件中的對象數據或者把網路節點上的對象數據,恢復成Java對象的過程.

為什麼要做序列化:

1):在分布式系統中,需要共享的數據的JavaBean對象,都得做序列化,此時需要把對象再網路上傳輸,此時就得把對象數據轉換為二進制形式.以後存儲在HttpSession中的對象,都應該實現序列化介面(只有實現序列化介面的類,才能做序列化操作).

2):服務鈍化:如果服務發現某些對象好久都沒有活動了,此時伺服器就會把這些內存中的對象,持久化在本地磁碟文件中(Java對象-->二進制文件).如果某些對象需要活動的時候,現在內存中去尋找,找到就使用,找不到再去磁碟文件中,反序列化我們得對象數據,恢復成Java對象.

需要做序列化的對象的類,必須實現序列化介面:java.io.Serializable介面(標志介面[沒有抽象方法]).

底層會判斷,如果當前對象是Serializable的實例,才允許做序列化. boolean ret = Java對象 instanceof Serializable;

在Java中大多數類都已經實現Serializable介面.

Ⅳ Java中為什麼要序列化什麼時候用到序列化

序列化可以將內存中的類寫入文件或資料庫中。比如將某個類序列化後存為文件，下次讀取時只需將文件中的數據反序列化就可以將原先的類還原到內存中。也可以將類序列化為流數據進行傳輸。總的來說就是將一個已經實例化的類轉成文件存儲，下次需要實例化的時候只要反序列化即可將類實例化到內存中並保留序列化時類中的所有變數和狀態。
例如：hibernate中實體類的鈍化就是將類序列化後存入磁碟並釋放內存空間。

Ⅵ 什麼是java序列化，如何實現序列化

簡單來說，如果你只是自己同一台機器的同一個環境下使用同一個JVM來操作，序列化和反序列化是沒必要的，當需要進行數據傳輸的時候就顯得十分必要。比如你的數據寫到文件里要被其他人的電腦的程序使用，或者你電腦上的數據需要通過網路傳輸給其他人的程序使用，像伺服器客戶端的這種模型就是一種應用，這個時候，大家想想，每個人的電腦配置可能不同，運行環境可能也不同，位元組序可能也不同，總之很多地方都不能保證一致，所以為了統一起見，我們傳輸的數據或者經過文件保存的數據需要經過序列化和編碼等操作，相當於交互雙方有一個公共的標准，按照這種標准來做，不管各自的環境是否有差異，各自都可以根據這種標准來翻譯出自己能理解的正確的數據。

除了在持久化對象時會用到對象序列化之外，當使用RMI(遠程方法調用)，或在網路中傳遞對象時，都會用到對象序列化。實現序列化：

1 首先要把准備要序列化類，實現 Serializabel介面

importjava.io.Serializable;
{
//本類可以序列化
privateStringname;
privateintage;
publicPerson(Stringname,intage)
{
this.name=name;this.age=age;
}
publicStringtoString()
{
return"姓名："+this.name+"，年齡"+this.age;
}
}

2 序列化

packageorg.lxh.SerDemo;
importjava.io.File;
importjava.io.FileOutputStream;
importjava.io.ObjectOutputStream;

{
//序列化
publicstaticvoidmain(String[]args)throwsException
{
//序列化後生成指定文件路徑
Filefile=newFile("D:"+File.separator+"person.ser");
ObjectOutputStreamoos=null;
//裝飾流（流）
oos=newObjectOutputStream(newFileOutputStream(file));
//實例化類
Personper=newPerson("張三",30);
oos.writeObject(per);
//把類對象序列化
oos.close();
}
}

需要注意的是：

靜態成員是不能被序列化的，因為靜態成員是隨著類的載入而載入的，與類共存亡，並且靜態成員的默認初始值都是0；就是說靜態成員屬於類級別的，所以不能序列化，序列化只是序列化了對象而已。

Ⅶ java中如何實現序列化，有什麼意義

首先我們要把准備要序列化類，實現 Serializabel介面
例如：我們要Person類里的name和age都序列化
import java.io.Serializable;

public class Person implements Serializable { //本類可以序列化
private String name ;
private int age ;

public Person(String name,int age){
this.name = name ;
this.age = age ;
}
public String toString(){
return "姓名：" + this.name + "，年齡" + this.age ;
}
}
然後：我們將name和age序列化（也就是把這2個對象轉為二進制，統族理解為「打碎」）
package org.lxh.SerDemo;
import java.io.File;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream ;
public class ObjectOutputStreamDemo { //序列化
public static void main(String[] args) throws Exception {
//序列化後生成指定文件路徑
File file = new File("D:" + File.separator + "person.ser") ; ObjectOutputStream oos = null ;
//裝飾流（流）
oos = new ObjectOutputStream(new FileOutputStream(file)) ;

//實例化類
Person per = new Person("張三",30) ; oos.writeObject(per) ;//把類對象序列化
oos.close() ;
}
}

Ⅷ java中的序列化是什麼意思

1. 序列化是將對象狀態轉換為可保持或傳輸的格式的過程。說白點就是你可以用對象輸出流輸出到文件。如果不序列化輸出的話，很可能會亂。

2. java中的序列化機制能夠將一個實例對象（只序列化對象的屬性值，而不會去序列化什麼所謂的方法。）的狀態信息寫入到一個位元組流中使其可以通過socket進行傳輸、或者持久化到存儲資料庫或文件系統中；然後在需要的時候通過位元組流中的信息來重構一個相同的對象。

3. 一般而言，要使得一個類可以序列化，只需簡單實現java.io.Serializable介面即可。

Ⅸ java中方法能不能序列化，如果能，怎樣使方法不被序列化和序列化

方法不需要序列化。
因為方法本身是數據處理操作（而非數據存儲操作），而序列化操作是對數據進行操作的。如果你的實體類被反序列化成為有方法的對象，那麼這個方法一樣可用。

Ⅹ Java中如何實現序列化，有什麼意義

序列化就是一種用來處理對象流的機制，所謂對象流也就是將對象的內容進行流化。可以對流化後的對象進行讀寫操作，也可將流化後的對象傳輸於網路之間。序列化是為了解決對象流讀寫操作時可能引發的問題（如果不進行序列化可能會存在數據亂序的問題）。
要實現序列化，需要讓一個類實現Serializable介面，該介面是一個標識性介面，標注該類對象是可被序列化的，然後使用一個輸出流來構造一個對象輸出流並通過writeObject(Object)方法就可以將實現對象寫出（即保存其狀態）；如果需要反序列化則可以用一個輸入流建立對象輸入流，然後通過readObject方法從流中讀取對象。序列化除了能夠實現對象的持久化之外，還能夠用於對象的深度克隆。