transient和volatile兩個關鍵字一個用於物件序列化簡單總結一下。

transient

transient是型別修飾符，只能用來修飾字段。在物件序列化的過程中，標記為transient的變數不會被序列化。

示例：

當類Test的例項物件被序列化（比如將Test類的例項物件 t 寫入硬碟的文字檔案t.txt中），變數 a 的內容不會被儲存，變數 b 的內容則會被儲存。

參考：
把一個物件的表示轉化為位元組流的過程稱為序列化（也稱為序列化，serialization），從位元組流中把物件重建出來稱為反序列化（也稱為為反序列化，deserialization）。transient 為不應被序列化的資料提供了一個語言級的標記資料方法。

 我們知道Java中對檔案操作有6種流：

             1 檔案位元組流：這是InputStream和OutputStream的子類 eg: FileInputStream  FileOutputStream

             2 檔案字元流    這是Reader和Writer的其子類  eg：FileReader    FileWriter    

             3 緩衝流   BufferReader類建立的物件稱為緩衝輸入流，該輸入流的指向必須是一個Reader流，稱為BufferReader的底層流，底層流負責將資料讀入到緩衝區，BufferReader流的源就是這個緩衝區，緩衝輸入流再從緩衝區讀取資料；同樣的， BufferWriter類建立的物件稱為緩衝輸出流，該輸入流的指向必須是一個Writer流，稱為BufferWriter的底層流，BufferWriter流負責將資料寫入到緩衝區，底層流的源就是這個緩衝區，底層流

            4 資料流    DataInputStream和DataOutputStream建立的物件稱為資料輸入流和資料輸出流，這兩個流允許程式按照與機器無關的風格讀取Java原始資料。也就是說我們讀取一個數值時候，不必關心這個數值應當是多少位元組。

            5 物件流    ObjectInputStream和ObjectOutputStream類分別是InputStream和OutputStream的子類。ObjectInputStream和ObjectOutputStream建立的物件稱為物件輸入流和物件輸出流，物件輸出流使用WriteObject(Object obj)方法將一個物件Obj寫入輸出流送往目的地，物件輸入流則使用readObject()方法從源中讀取一個物件到程式中。下面我著重講解物件流

         當我們使用物件流寫入或者讀取物件時，要保證物件是序列化的，這是為了保證能把物件寫入到檔案，並且從檔案中正確讀取到程式中。一個類如果實現了Serializable介面，那麼這個類建立的物件就是序列化的物件，Serializable介面中的方法對程式是不可見的，因此實現該介面的類不需要實現額外的方法，當把一個序列化的物件寫入到物件輸出流的時候，JVM會自動的實現Serializable介面中的方法，按照一定格式的文字將物件寫入到目的地。

但是我們應該明確，物件流寫入到檔案是以16進位制儲存的，因此使用普通的編輯器開啟（word，記事本）會亂碼，物件流本來就是適合網路之間的傳輸。

      另外我們必須要明確是：使用readObject()只能從檔案中讀取一個一次，不能像BufferReader的readLine()方法一樣可以迴圈控制中讀取輸入，也就是說如果檔案中存在多個物件，那麼只是讀取第一個物件，例如：

1. package inputoutputStream;  
2. import java.io.File;  
3. import java.io.FileInputStream;  
4. import java.io.FileNotFoundException;  
5. import java.io.FileOutputStream;  
6. import java.io.IOException;  
7. import java.io.ObjectInputStream;  
8. import java.io.ObjectOutputStream;  
9. import java.io.Serializable;  
10. import java.util.ArrayList;  
11. import java.util.List;  
12.  class TV implements Serializable{  
13.     privateint price;  
14.     privatedouble weigth;  
15.     private String describe;  
16.     privateboolean isNice;  
17.      List<List<String>> list;  
18.     public TV(){  
19.         list=new ArrayList<>();  
20.         for(int i=0;i<10;i++)  
21.             list.add(new ArrayList<String>());  
22.     }  
23.     public List<List<String>> getList() {  
24.         return list;  
25.     }  
26.     publicvoid setList(List<List<String>> list) {  
27.         this.list = list;  
28.     }  
29.     publicint getPrice() {  
30.         return price;  
31.     }  
32.     publicvoid setPrice(int price) {  
33.         this.price = price;  
34.     }  
35. publicdouble getWeigth() {  
36.         return weigth;  
37.     }  
38.     publicvoid setWeigth(double weigth) {  
39.         this.weigth = weigth;  
40.     }  
41.     public String getDescribe() {  
42.         return describe;  
43.     }  
44.     publicvoid setDescribe(String describe) {  
45.         this.describe = describe;  
46.     }  
47.     publicboolean isNice() {  
48.         return isNice;  
49.     }  
50.     publicvoid setNice(boolean isNice) {  
51.         this.isNice = isNice;  
52.     }  
53. }  
54. publicclass ObjectStream {  
55.     private TV t;  
56.     privatefinalstatic String OUTPUT="C:\\Users\\samsung\\Desktop\\weiwei.txt";  
57.     public ObjectStream(){  
58.         t=new TV();  
59.         t.setNice(true);  
60.         t.setDescribe("very nice~~");  
61.         t.setPrice(800);  
62.         t.setWeigth(200.23);  
63.         for(int i=0;i<10;i++){  
64.             for(int j=0;j<4;j++)  
65.                 t.list.get(i).add("["+(i+3)+","+j+"]");  
66.         }  
67.     }  
68.     publicvoid write(TV tv) throws FileNotFoundException, IOException{  
69.         File file=new File(OUTPUT);  
70.         /*TV []data=new TV[2]; 
71.         data[0]=tv;data[1]=tv;*/
72.         ObjectOutputStream objectOutputStream=new ObjectOutputStream(new FileOutputStream(file,false));  
73.         //objectOutputStream.writeObject(data);
74.         objectOutputStream.writeObject(tv);  
75.         objectOutputStream.close();  
76.         System.out.println("write over~!~~");  
77.     }  
78.     publicvoid read(TV tv) throws FileNotFoundException, IOException, ClassNotFoundException{  
79.         File file=new File(OUTPUT);  
80.         ObjectInputStream inputStream =new ObjectInputStream(new FileInputStream(file));  
81.         TV v=(TV) inputStream.readObject();  
82.         //List<TV> s=new ArrayList<>();
83.         //TV vv[]= (TV[]) inputStream.readObject();
84.         //TV []vv=(TV[])inputStream.readObject();
85.         //for(TV v:vv){
86.             System.out.println(v.getDescribe());  
87.             System.out.println(v.getPrice());  
88.             System.out.println(v.isNice());  
89.             System.out.println(v.getWeigth());  
90.             System.out.println(v.getList());  
91.         //}
92.     }  
93.     publicvoid writeChar() throws Exception{  
94.         String output="C:\\Users\\samsung\\Desktop\\ww.txt";  
95.         String s="上來的飛機上開發是卡洛斯的房間裡誰";  
96.         File file=new File(output);  
97.         FileOutputStream stream=
    相關推薦

    Java關鍵字transient和java物件流

    transient和volatile兩個關鍵字一個用於物件序列化簡單總結一下。transienttransient是型別修飾符，只能用來修飾字段。在物件序列化的過程中，標記為transient的變數不會被序列化。示例：class Test {transient int a;

    Java關鍵字transient和volatile小結

    java pre txt 關鍵字 代碼 字段 代碼優化 class 保存 transient 類型修飾符，只能用來修飾字段。 在對象序列化的過程中，標記為transient的變量不會被序列化。 class Test { transient int a; // 不

    【JSON 註解】JSON迴圈引用2----JSON註解@JsonIgnoreProperties+JAVA關鍵字transient+後臺物件與JSON資料的格式互相轉化

    接著來說這個JSON迴圈引用的問題： @JsonIgnoreProperties({"hibernateLazyInitializer", "org","roles"})  在實體類上註解，在使用jackjson 來解析就行 參考下面 關於JSON格式的轉化，其實關

    Java關鍵字-transient

    基本類 支持 作用 jdk nal 自動 過程 自定義 表示 transient的作用 針對實現了Serilizable接口（對象傳輸時候自動進行序列化操作）的對象，在指定的變量前加transient關鍵字，表示該變量不參與序列化。即在序列化過程中該變量的值為空。 tran

    java 字節流和字符流轉換類InputStreamReader，OutPutStreamReader

    spa modified num cep enter import stat avi buffer import java.io.*; public cla

    java--字節流和字符流的轉換

    int readline buffer nbsp port pack ati AC AI package com.machuang.convertStream; import java.io.BufferedReader; import java.io.File

    Java關鍵字final和static的作用

    ++ 修改 AS apr super關鍵字 存在 回收 TP javap 一、關鍵字final final修飾類：這個類就不能被繼承 final修飾方法：不能被重寫 final修飾屬性：此屬性就是一個常量，一旦初始化後，不可再被賦值。習慣上，

    Java——構造方法和匿名物件

    前言 在編寫程式時不安全的初始化會導致程式發生發生重大錯誤。為了使程式可以被安全地初始化，C++引入了構造器（也可以成為構造方法）的概念，這是一個在建立物件時被自動呼叫的特殊方法。Java中也採用了構造器，並且提供了“垃圾回收器”。對於不在使用的記憶體資源，垃圾回收器能自動將其釋放。本篇文章主要介紹Java

    Java基礎Demo -- IO 操作物件流

    ObjectInputStream和ObjectOutputStream的簡單運用 import java.io.*; class MyClass implements Serializable { private String name = "dindoa"; private int a

    java關鍵字Transient

    Java的serialization提供了一種持久化物件例項的機制。當持久化物件時，可能有一個特殊的物件資料成員，我們不想用serialization機制來儲存它。為了在一個特定物件的一個域上關閉serialization，可以在這個域前加上關鍵字transient。tran

    javax.xml + java.io xml和java物件互轉工具類

    import javax.xml.bind.JAXBContext; import javax.xml.bind.JAXBException; import javax.xml.bind.Marshaller; import javax.xml.bind.Unmarshall

    Java字串常量和static物件的區別

    java中將記憶體分為四個區：heap、stack、data segment、code segment； 字串常量和靜態變數都存於資料區；字串常量存於資料區，如果內容相同，則地址指向相同；靜態變數也存

    Java 儲存模型和共享物件詳解

    Java 儲存模型和共享物件詳解 很多程式設計師對一個共享變數初始化要注意可見性和安全釋出（安全地構建一個物件，並其他執行緒能正確訪問）等問題不是很理解，認為Java是一個遮蔽記憶體細節的平臺，連物件回收都不需要關心，因此談到可見性和安全釋出大多不知所云。其實關鍵在於對Java儲存模型，可見性和

    JVM記憶體結構、Java記憶體模型和Java物件模型，你知道它們之間的區別嗎？

    Java作為一種面向物件的，跨平臺語言，其物件、記憶體等一直是比較難的知識點。而且很多概念的名稱看起來又那麼相似，很多人會傻傻分不清楚。比如本文我們要討論的JVM記憶體結構、Java記憶體模型和Java物件模型，這就是三個截然不同的概念，但是很多人容易弄混。可以這樣說，很多高

    Java關鍵字——transient

    “transient”——“瞬態”，先不說這個翻譯是否恰當，這個變數關鍵字一直不曾使用，簡單的說就是被瞬態定義的變數不可序列號。或者這麼給他換個名字——“不可序列化狀態”？打個比方，如果一個使用者有一些敏感資訊（譬如密碼，銀行卡號等），為了安全起見，不希望在網路操作（主要涉及

    Java關鍵字null和" "

    0、null與""的區別 String s=null;//null是未分配堆記憶體空間 String a;//分配了一個記憶體空間,沒存入任何物件 String a="";//分配了一個記憶體空間,存了一個字串物件 null是用來判斷引用型別是否分配了儲存空間 1、null是代表不確定的物件 J

    java關鍵字transient與序列化相關

    它標記一個成員變數，當它被持續到位元組流時不被序列化。 當通過網路傳輸物件時，物件需要“序列化”。 序列化將物件狀態轉換為序列位元組。 這些位元組通過網路傳送，並且從這些位元組重新建立物件。 由java transient關鍵字標記的成員變數不傳輸，故意丟失。 可以類比hi

    JVM記憶體結構、Java記憶體模型和Java物件模型

    Java作為一種面向物件的，跨平臺語言，其物件、記憶體等一直是比較難的知識點。而且很多概念的名稱看起來又那麼相似，很多人會傻傻分不清楚。比如本文要討論的JVM記憶體結構、Java記憶體模型和Java物件模型，這就是三個截然不同的概念，但是很多人容易弄混。 首先，這三個概念是完全不同的三個概念。本文主要目的是對

    Java基礎IO類之物件流與序列化

    物件流的兩個類： 　　ObjectOutputStream：將Java物件的基本資料型別和圖形寫入OutputStream 　　ObjectInputStream：對以前使用ObjectOutputStream寫入的基本資料和物件進行反序列化 序列化一組物件： 　　在系列化操作中，同時序列化多個物件時，反序列

    用非常硬核的JAVA序列化手段實現物件流的持久化儲存

    [toc] #### 背景 在OOP（面向物件程式設計）中處處是物件，我們當然希望可以有一種資料格式來儲存這種物件的集合，以實現持久化。比如部門類所形成的部門物件集合，員工類所形成的員工物件集合，甚至是這樣一個類所形成的物件：公司中有多個部門，每個部門有多個員工，我們希望將這樣一個物件以檔案的方式實現持久化儲