Java淺談流之物件流ObjectInputStream和ObjectOutputStream
我們知道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()方法一樣可以迴圈控制中讀取輸入，也就是說如果檔案中存在多個物件，那麼只是讀取第一個物件，例如：
package inputoutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
class TV implements Serializable{
private int price;
private double weigth;
private String describe;
private boolean isNice;
List<List<String>> list;
public TV(){
list=new ArrayList<>();
for(int i=0;i<10;i++)
list.add(new ArrayList<String>());
}
public List<List<String>> getList() {
return list;
}
public void setList(List<List<String>> list) {
this.list = list;
}
public int getPrice() {
return price;
}
public void setPrice(int price) {
this.price = price;
}
public double getWeigth() {
return weigth;
}
public void setWeigth(double weigth) {
this.weigth = weigth;
}
public String getDescribe() {
return describe;
}
public void setDescribe(String describe) {
this.describe = describe;
}
public boolean isNice() {
return isNice;
}
public void setNice(boolean isNice) {
this.isNice = isNice;
}
}
public class ObjectStream {
private TV t;
private final static String OUTPUT="C:\\Users\\samsung\\Desktop\\weiwei.txt";
public ObjectStream(){
t=new TV();
t.setNice(true);
t.setDescribe("very nice~~");
t.setPrice(800);
t.setWeigth(200.23);
for(int i=0;i<10;i++){
for(int j=0;j<4;j++)
t.list.get(i).add("["+(i+3)+","+j+"]");
}
}
public void write(TV tv) throws FileNotFoundException, IOException{
File file=new File(OUTPUT);
/*TV []data=new TV[2];
data[0]=tv;data[1]=tv;*/
ObjectOutputStream objectOutputStream=new ObjectOutputStream(new FileOutputStream(file,false));
//objectOutputStream.writeObject(data);
objectOutputStream.writeObject(tv);
objectOutputStream.close();
System.out.println("write over~!~~");
}
public void read(TV tv) throws FileNotFoundException, IOException, ClassNotFoundException{
File file=new File(OUTPUT);
ObjectInputStream inputStream =new ObjectInputStream(new FileInputStream(file));
TV v=(TV) inputStream.readObject();
//List<TV> s=new ArrayList<>();
//TV vv[]= (TV[]) inputStream.readObject();
//TV []vv=(TV[])inputStream.readObject();
//for(TV v:vv){
System.out.println(v.getDescribe());
System.out.println(v.getPrice());
System.out.println(v.isNice());
System.out.println(v.getWeigth());
System.out.println(v.getList());
//}
}
public void writeChar() throws Exception{
String output="C:\\Users\\samsung\\Desktop\\ww.txt";
String s="上來的飛機上開發是卡洛斯的房間裡誰";
File file=new File(output);
FileOutputStream stream=new FileOutputStream(file);
stream.write(s.getBytes());
stream.close();
}
public void readChar()throws Exception{
String output="C:\\Users\\samsung\\Desktop\\ww.txt";
File file=new File(output);
FileInputStream stream=new FileInputStream(file);
byte b[]=new byte[200];
while(stream.read(b, 0, 200)!=-1){
String string=new String(b);
System.out.println(string);
}
stream.close();
}
public static void main(String[] args) throws Exception {
ObjectStream stream=new ObjectStream();
stream.write(stream.t);
stream.read(stream.t);
/*stream.writeChar();
stream.readChar();*/
}
}
但是當我們想要存放多個物件到某一個檔案中並且想要讀取的時候把所有的物件都讀取出來，那麼我們必須使用一種資料結構把這些物件存入，比喻list或者直接使用陣列，並且必須保證存入時的資料結構和取出時的資料結構是一樣的，比喻我們使用陣列存放了物件，然後使用writerObject方法把這個陣列寫入，那麼我們在使用readObject方法讀取資料的時候必須將其返回型別定義為一個物件陣列，例如：注意下面的程式碼和上面的程式碼的細微變化：
package inputoutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
class TV implements Serializable{
private int price;
private double weigth;
private String describe;
private boolean isNice;
List<List<String>> list;
public TV(){
list=new ArrayList<>();
for(int i=0;i<10;i++)
list.add(new ArrayList<String>());
}
public List<List<String>> getList() {
return list;
}
public void setList(List<List<String>> list) {
this.list = list;
}
public int getPrice() {
return price;
}
public void setPrice(int price) {
this.price = price;
}
public double getWeigth() {
return weigth;
}
public void setWeigth(double weigth) {
this.weigth = weigth;
}
public String getDescribe() {
return describe;
}
public void setDescribe(String describe) {
this.describe = describe;
}
public boolean isNice() {
return isNice;
}
public void setNice(boolean isNice) {
this.isNice = isNice;
}
}
public class ObjectStream {
private TV t;
private final static String OUTPUT="C:\\Users\\samsung\\Desktop\\weiwei.txt";
public ObjectStream(){
t=new TV();
t.setNice(true);
t.setDescribe("very nice~~");
t.setPrice(800);
t.setWeigth(200.23);
for(int i=0;i<10;i++){
for(int j=0;j<4;j++)
t.list.get(i).add("["+(i+3)+","+j+"]");
}
}
public void write(TV tv) throws FileNotFoundException, IOException{
File file=new File(OUTPUT);
TV []data=new TV[2];
data[0]=tv;data[1]=tv;
ObjectOutputStream objectOutputStream=new ObjectOutputStream(new FileOutputStream(file,false));
objectOutputStream.writeObject(data);
//objectOutputStream.writeObject(tv);
objectOutputStream.close();
System.out.println("write over~!~~");
}
public void read(TV tv) throws FileNotFoundException, IOException, ClassNotFoundException{
File file=new File(OUTPUT);
ObjectInputStream inputStream =new ObjectInputStream(new FileInputStream(file));
//TV v=(TV) inputStream.readObject();
//List<TV> s=new ArrayList<>();
//TV vv[]= (TV[]) inputStream.readObject();
TV []vv=(TV[])inputStream.readObject();
for(TV v:vv){
System.out.println(v.getDescribe());
System.out.println(v.getPrice());
System.out.println(v.isNice());
System.out.println(v.getWeigth());
System.out.println(v.getList());
}
}
public void writeChar() throws Exception{
String output="C:\\Users\\samsung\\Desktop\\ww.txt";
String s="上來的飛機上開發是卡洛斯的房間裡誰";
File file=new File(output);
FileOutputStream stream=new FileOutputStream(file);
stream.write(s.getBytes());
stream.close();
}
public void readChar()throws Exception{
String output="C:\\Users\\samsung\\Desktop\\ww.txt";
File file=new File(output);
FileInputStream stream=new FileInputStream(file);
byte b[]=new byte[200];
while(stream.read(b, 0, 200)!=-1){
String string=new String(b);
System.out.println(string);
}
stream.close();
}
public static void main(String[] args) throws Exception {
ObjectStream stream=new ObjectStream();
stream.write(stream.t);
stream.read(stream.t);
/*stream.writeChar();
stream.readChar();*/
}
}
這裡使用了一個物件陣列data將兩個物件存入並且讀出的時候使用了物件陣列來接收。
相關推薦
Java淺談流之物件流ObjectInputStream和ObjectOutputStream
我們知道Java中對檔案操作有6種流： 1 檔案位元組流：這是InputStream和OutputStream的子類 eg: FileInputStream FileOutputStream 2 檔案字元流
Java流之物件流
物件流 物件流屬於高階流,通過這組流可以方便的讀寫java中的任何物件. 物件輸出流:用於寫出物件,由於底層讀寫都是位元組讀寫,所以無論什麼樣的資料都要轉換為位元組才能寫出.物件輸出流可以自行將給定的物件轉換為一組位元組然後寫出.這樣可以省去我
Java基礎IO類之物件流與序列化
物件流的兩個類： ObjectOutputStream：將Java物件的基本資料型別和圖形寫入OutputStream ObjectInputStream：對以前使用ObjectOutputStream寫入的基本資料和物件進行反序列化 序列化一組物件： 在系列化操作中，同時序列化多個物件時，反序列
JAVA高階視訊_IO輸入與輸出 ObjectInputStream和ObjectOutputStream類 學習筆記
這兩個包裝類用於從底層輸入流中讀取物件型的資料和將物件型的資料寫到底層輸出流,只要將物件的所有的成員變數都儲存起來,就等於儲存了這個物件，只要將原來儲存的成員變數讀取出來儲存在物件中,就等於讀取到了一個物件,這兩個包裝類讀寫的物件必須是實現了serializable介面的物件
Java筆記-I/O流之物件序列化流
物件序列化流 物件序列化流基本介紹 使用工具：ObjectOutputStream，ObjectInputStream 介紹：將物件以檔案的形式儲存在硬碟中，使之能更方便的傳輸。 條件：必須實現Serializable介面（實現了這個介面，但
Java之IO流進階篇：記憶體流，列印流，物件流
Java中的IO流，即為輸入輸出流。所謂輸入輸出流，都是相對於程式而言，程式就是這個參照物。一張圖看懂輸入輸出流： 輸入流抽象基類：InputStream,Reader 輸出流抽象基類：OutputStream,Writer 輸入輸出流子類眾多，詳情見下圖： 1.記
Java-IO流之轉換流的使用和編碼與解碼原理
鍵盤輸入 tostring delet 特點 rgb utf8 equals pri 數據 一、理論： 1、字符流和字節流區別是什麽？ 字符流=字節流+編碼集，在實際讀取的時候其實字符流還是按照字節來讀取，但是會更具編碼集進行查找編碼集字典解析相應的字節，使得一次讀取出一個
Java IO流之字元流
1.字元輸出流 Writer（只能寫入文字檔案） 1.1FileWriter類（writer的子類） 構造方法： public class FileWriterDemo { public static void main(String[] args) throws IOE
java day22 IO流 序列流，物件流，資料流，列印流
22.01_IO流(序列流)(瞭解) 1.什麼是序列流 序列流可以把多個位元組輸入流整合成一個, 從序列流中讀取資料時, 將從被整合的第一個流開始讀, 讀完一個之後繼續讀第二個, 以此類推. 2.使用方式 整合兩個:
Java中級進階之IO流
IO流 1.流 概念：流就是一系列的資料 1.1 什麼是流 ① 當不同的介質之間有資料互動的時候，JAVA就使用流來實現 ② 資料來源可以是檔案，還可以是資料庫，網路甚至是其他的程式 ③ 比如讀取檔案的資料到程式中，站在程式的角度來看，就叫做輸入流
跟我學 Java 8 新特性之 Stream 流（四）並行流
隨著對流API認識的慢慢深入，本章我們要討論的知識點是流API裡面的並行流了。 在開始討論並行流之前，我先引發一下大家的思考，就你看到這篇文章的時間，你們是不是經常聽到，Intel i7 CPU什麼8核16執行緒，什麼Android手機8核4GB這種訊息，既然我們是處於
跟我學 Java 8 新特性之 Stream 流（三）縮減操作
和前面兩篇文章一起服用，效果會更佳。通過對流API的基礎體驗Demo和關鍵知識點的講解，相信大家對流API都有一定的認識了，但是流API強大的功能，可不僅僅像前面兩篇文章中說的那樣簡單，大家應該注意到，在第二篇中，我對Stream介面進行介紹的時候，並沒有把他的全部方法都
跟我學 Java 8 新特性之 Stream 流（二）關鍵知識點
我們的第一篇文章，主要是通過一個Demo，讓大家體驗了一下使用流API的那種酣暢淋漓的感覺。如果你沒有實踐，我還是再次呼籲你動手敲一敲，自己實實在跑一遍上一篇的Demo。 相信你的感受和理解也會隨之加深的。繼續探索流API的高階功能之前，我們先從介面級別全面瞭解一下流A
跟我學 Java 8 新特性之 Stream 流基礎體驗
Java8新增的功能中,要數lambda表示式和流API最為重要了.這篇文章主要介紹流API的基礎,也是流API系列的第一篇文章,話不多說,直奔主題. 什麼是流API? 它能做一些什麼? 我們應該知道(絕對知道~)API是一個程式向使用者提供的一些方法,通過這些方法就
跟我學 Java 8 新特性之 Stream 流（六）收集
我們前面的五篇文章基本都是在說將一個集合轉成一個流，然後對流進行操作，其實這種操作是最多的，但有時候我們也是需要從流中收集起一些元素，並以集合的方式返回，我們把這種反向操作稱為收集。 流API也給我們提供了相應的方法。 如何在流中使用收集功能？ 我們先看一看流API
跟我學 Java 8 新特性之 Stream 流（七）流與迭代器，流系列大結局
恭喜你們，馬上就要學完Java8 Stream流的一整系列了，其實我相信Stream流對很多使用Java的同學來說，都是一個知識盲點，因為這個原因，我才這麼細緻地講解Stream流的各個知識點，通過這一整個系列，我相信只要認真看了的同學，都已掌握的差不多了，就差實戰了。
物件流（objectInputStream 和ObjectOutputStream）
一、對面序列化過程 ：將記憶體中的物件通過ObjectOutputStream轉為二進位制流，儲存在硬碟檔案中 對面序列化要滿足的條件 1、物件所對應的類要實現Serializable介面 2、類的屬性同樣要實現Serializable介面 3、凡是實現Seriali
JAVA的IO流之緩衝流
JAVA緩衝流本身不具IO功能，只是在別的流上加上緩衝提高效率，像是為別的流裝上一種包裝。當對檔案或其他目標頻繁讀寫或操作效率低，效能差。這時使用緩衝流能夠更高效的讀寫資訊。因為緩衝流先將資料快取起來，然後一起寫入或讀取出來。所以說，緩衝流還是很重要的，在IO操
Java學習筆記之--------IO流之字元流實現純文字拷貝
字元流 輸入流：Reader，FileReader 輸出流：Writer，FileWriter 字元流只能處理純文字，全部為可見字元（.txt或者.html）。下面實現純文字的拷貝： public class CopyFileDemo { public sta
Java學習筆記之--------IO流之緩衝流
緩衝流 位元組緩衝流：BufferedInputStream，BufferedOutputStream 字元緩衝流：BufferedReader，readLine()，BufferedWriter，newLine() 我們實現位元組流檔案拷貝+緩衝流，提高效能： pu