2. 程式人生 > >Java筆記(7)-輸入、輸出流、File類、InputStream、Reader、檔案位元組流、檔案字元流、緩衝流、隨機流、資料流、物件流、序列化和物件克隆、Scanner解析檔案、Console流

Java筆記(7)-輸入、輸出流、File類、InputStream、Reader、檔案位元組流、檔案字元流、緩衝流、隨機流、資料流、物件流、序列化和物件克隆、Scanner解析檔案、Console流

阿新 • • 發佈：2019-01-26

所有的合適都是兩個人的相互遷就和改變，沒有天生合適的兩個人，兩個人朝著相同的方向努力，就是最好的愛情。

輸入、輸出流

這裡寫圖片描述

Io體系

什麼是“流”。直觀地講，流就像水一樣，不存在大小問題，也避免了完整性問題。非流的資料傳輸，比如你下載一張圖片，需要整幅圖片下載完之後才能使用，而流則不同，就像水，你取一杯也可以用，取一桶也可以用。所以說，流是一種資料傳輸的模式。

輸入流和輸出流，差別在於出和入，是相對於“使用程式”這個參照物而言的。如果資料的流向是程式至裝置，我們稱為輸出流，反之我們稱為輸入流。伺服器端的輸出流對應就是接受客戶端的輸入流

輸出流和輸入流，二者沒有必然的聯絡，都是流，差別是方向不同，也就是說，程式可以只有輸入流而沒有輸出流，或者只有輸出流而沒有輸入流。

輸入流

程式在執行期間，可能需要從外部的儲存媒介或其他程式中讀入所需要的資料，這就是需要使用輸入流物件。

這裡寫圖片描述

輸出流

程式在使用資料後，可能需要將處理的結果寫入到永久的儲存媒介中或傳送給其他的應用程式，這就需要輸出流物件。

這裡寫圖片描述

1 File 類

File構造方法

File(String filename);
File(String directoryPath,String filename);
File(File f,String filename);

filename是檔名字，directoryPath是檔案的路徑，f是指定成一個目錄的檔案。是用那個File(String filename )

建立檔案時，該檔案被認為與當前應用程式在同一個目錄。

File屬性

    public String getName() 返回檔名或目錄名
    public boolean exists() 判斷檔案或目錄是否存在
    public boolean isFile() 判斷是檔案還是目錄 
    public boolean isDirectory() 判斷是檔案還是目錄
    public boolean isHidden() 判斷檔案是否是隱藏檔案
    public boolean canRead() 判斷檔案是否可讀
    public boolean canWrite
 
() 判斷檔案是否可寫
    public String getPath() 返回檔案或目錄的路徑
    public String getAbsolutePath() 返回檔案的絕對路徑
    public long length() 獲取檔案的長度 
    public String getParent() 獲取檔案的父目錄
    public long lastModified() 獲取檔案的最後修改的時間（時間是從1970年午夜至檔案最後修改時刻的毫秒數）

    File類中還定義了一些對檔案或目錄進行管理、操作的方法，常用的方法有：
    public String[ ] list () 將目錄中所有檔名儲存在字串陣列中返回。 
    public boolean renameTo( File newFile );    重新命名檔案
    public boolean createNewFile();  建立檔案
    public void delete();   刪除檔案
    public boolean mkdir(); 建立目錄

檔案路徑問題

1、java中“\”是轉義字元，“\”表示的是一個”\”，以此類推，“\\”表示兩個”\”；“\\\\”表示的是四個”\”。
2、“/ ”一個時表示除號,
3、“//”兩個時表示單行註釋。
4、在字串中“/”和“\”也代表是路徑。

File f = new File("D:\\eclipse\\workspace\\File\\src\\com\\file","Main2.java");
File f = new File("D:/eclipse/workspace/File/src/com/file","Main2.java");

示例

import java.io.File;
import java.io.IOException;

public class Main2 {
    public static void main(String[] args) {
        File f = new File("D:\\eclipse\\workspace\\File\\src\\com\\file","Main2.java");
        //File f = new File("D:/eclipse/workspace/File/src/com/file","Main2.java");
        System.out.println(f.getName() + "是可讀的嗎：" + f.canRead());
        System.out.println(f.getName() + "的長度：" + f.length());
        System.out.println(f.getName() + "的絕對路徑：" + f.getAbsolutePath());
        System.out.println("檔案父目錄字串 "+f.getParent());// 返回此抽象路徑名父目錄的路徑名字串；如果此路徑名沒有指定父目錄，則返回 null。  
        System.out.println("該分割槽大小"+f.getTotalSpace()/(1024*1024*1024)+"G"); //返回由此抽象路徑名錶示的檔案或目錄的名稱。  
        File file = new File("new.txt");
        System.out.println("在當前目錄下建立新檔案" + file.getName());
        if (!file.exists()) {
            try {
                file.createNewFile();
                System.out.println("建立成功");
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

Main2.java是可讀的嗎：true
Main2.java的長度：1045
Main2.java的絕對路徑：D:\eclipse\workspace\File\src\com\file\Main2.java
檔案父目錄字串 D:\eclipse\workspace\File\src\com\file
該分割槽大小800G
在當前目錄下建立新檔案new.txt

2 目錄

建立目錄

public boolean mkdir() 建立目錄，如果建立成功則返回true，否則返回false（如果目錄存在則返回false）

列出目錄中的檔案

如果File物件是一個目錄，下面的方法將會列出目錄下的檔案和子目錄。

public String[] list() 字串形式返回目錄下的全部檔案

public File[] listFiles() 用File物件形式返回目錄下的全部檔案

有時需要列出目錄下指定型別的檔案，如.java,.txt等副檔名的檔案。

public String [] list(FileNameFilter obj) 字串形式放回目錄下指定型別的所有檔案

public File [] listFiles(FileNameFilter obj) File物件形式放回目錄下指定型別的所有檔案

FilenameFilter是一個介面

public boolean accept(File dir,String name); 

引數obj不斷回撥介面方法accept(File dir,String name),該方法中的引數dir為呼叫list的當前目錄，引數name被例項化目錄的一個檔名，當介面方法返回true時，list方法就將名字為name的檔案存到陣列中。

這裡寫圖片描述

示例

import java.io.File;

public class Main3 {
    public static void main(String[] args) {

        File dir = new File("D:\\javafile");// 查詢的目錄

        FileAccept fileAccept = new FileAccept();
        fileAccept.setExtendname("java");
        String fileName[] = dir.list(fileAccept);
        System.out.println("-----字串返回.java字尾--------");
        for (String name : fileName) {
            System.out.println(name);
        }
        System.out.println("------字串返回所有--------");
        String fileName2[] = dir.list();
        for (String name : fileName2) {
            System.out.println(name);
        }
        System.out.println("------File物件返回所有-------");
        File[] fileName3 = dir.listFiles();
        for (File name : fileName3) {
            System.out.println(name);
        }
    }
}

-----字串返回.java字尾--------
ReturnTest.java
StudentTest.java
SwitchTest.java
Test.java
Testjiujiuchengfabiao.java
ThisDemo.java
Wolf.java
------字串返回所有--------
Animal.class
Creature.class
Person.class
ReturnTest.class
ReturnTest.java
shuzhu
Student.class
StudentTest.class
StudentTest.java
SwitchTest.java
Test.class
Test.java
Testjiujiuchengfabiao.class
Testjiujiuchengfabiao.java
TestOverWrite
TestSuperThis
TestYichang
ThisDemo.class
ThisDemo.java
Wolf.class
Wolf.java
空白文件.txt
------File物件返回所有-------
D:\javafile\Animal.class
D:\javafile\Creature.class
D:\javafile\Person.class
D:\javafile\ReturnTest.class
D:\javafile\ReturnTest.java
D:\javafile\shuzhu
D:\javafile\Student.class
D:\javafile\StudentTest.class
D:\javafile\StudentTest.java
D:\javafile\SwitchTest.java
D:\javafile\Test.class
D:\javafile\Test.java
D:\javafile\Testjiujiuchengfabiao.class
D:\javafile\Testjiujiuchengfabiao.java
D:\javafile\TestOverWrite
D:\javafile\TestSuperThis
D:\javafile\TestYichang
D:\javafile\ThisDemo.class
D:\javafile\ThisDemo.java
D:\javafile\Wolf.class
D:\javafile\Wolf.java
D:\javafile\空白文件.txt

檔案的刪除和建立

File file = new File("D:\\javafile","須木一瓜.txt");
        /*try {
            file.createNewFile();
        } catch (IOException e) {
            e.printStackTrace();
        }*/
        file.delete();
        System.out.println(file.exists());

執行可執行檔案

import java.io.File;
import java.io.IOException;

public class Runexe {
    public static void main(String[] args) {
        try {
            Runtime ce = Runtime.getRuntime();
            File file = new File("c:/windows", "Notepad.exe");
            ce.exec(file.getAbsolutePath());
            file = new File("C:\\Program Files\\Internet Explorer","IEXPLORE www.baidu.com");
            ce.exec(file.getAbsolutePath());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3 位元組流和字元流

流序列中的資料既可以是未經加工的原始二進位制資料，也可以是經一定編碼處理後符合某種格式規定的特定資料。因此Java中的流分為兩種：

位元組流：資料流中最小的資料單元是位元組
字元流：資料流中最小的資料單元是字元， Java中的字元是Unicode編碼，一個字元佔用兩個位元組。

在java中，位元組流讀取的最小單位是一個位元組（1byte=8bit），而字元流一次可以讀取一個字元（1char = 2byte = 16bit）。
按照ANSI編碼標準，標點符號、數字、大小寫字母都佔一個位元組，漢字佔2個位元組。按照UNICODE標準所有字元都佔2個位元組。

InputStream類與OutputStream類

Java把InputStream抽象類的子類建立的流物件稱作位元組輸入流，OutputStream抽象類的子類建立的流物件稱作位元組輸出流。

IntputStream的read()方法以位元組為單位順序地讀取源中的資料，只要不關閉流，每次呼叫read方法就順序的讀取源中的其餘內容，直到源的末尾或輸入流被關閉。

InputStream類的方法：

int read() 輸入流呼叫該方法從源中讀取單個位元組的資料，該方法返回位元組值（0~255之間的一個整數），如果未讀出就返回-1
void close() 關閉輸入流
int read(byte b[]) 從源中檢視讀取b.length個位元組到b中，返回實際讀取的位元組數目。到達末尾則返回-1

OutStream流以位元組為單位順序的寫檔案，只要不關閉檔案流，每次呼叫write方法就會順序地向目的地寫入內容，知道流被關閉。

OutputStream類的方法：

void write() 向輸出流中寫入單個位元組
void write(byte b[]) 向輸出流寫入一個位元組陣列
void close() 關閉輸出流

更多方法

Reader類與Writer類

Java把Reader抽象類的子類建立的流物件稱作字元輸入流，Writer抽象類的子類建立的流物件稱作字元輸出流。

Reader類提供的read方法以字元為單位順序地讀取源中的資料，只要不關閉流，每次呼叫read方法就書怒的讀取源中的其餘內容，直到源的末尾或輸入流被關閉。

Reader類方法：

int read() 從源中讀取一個字元，返回一個整數(0~65535之間的一個整數，Unicode字元值)，如果未讀出字元就返回-1。

int read(char b[]) 從源中讀取b.length個字元到字元陣列中b中，返回實際讀取的字元數目，到達末尾則返回-1。

void close() 關閉輸入流

OutStream流溢字元為單位順序的寫檔案，只要不關閉流，每次呼叫write方法就順序地向目的地寫入內容，直到流被關閉。

Writer類方法:

void write(int n) 向輸入流寫入一個字元。
void write(byte []) 向輸入流寫入一個字元陣列。
void close() 關閉輸出流

關閉流

　　流都提供了關閉方法close(),儘管程式結束時會自動關閉所有開啟的流，但是當程式使用完流後，顯示地關閉任何開啟的流仍是一個良好的習慣，如果沒有關閉那些被開啟的流，那麼就可能不允許另一個程式操作那些流所用的資源。另外，需要注意的是，在作業系統把程式寫的到輸出流上的那些位元組儲存到磁碟上之前，有時被存放在記憶體緩衝區中，通過呼叫close()方法，可以保證作業系統把流緩衝區的內容寫到目的地，即關閉輸出流可以把該流所用的緩衝區的內容沖洗掉（通常沖洗到磁碟檔案上）。

4 檔案位元組流

InputStream專門提供了讀寫檔案的子類：FileInputStream和FileOutStream類

檔案位元組輸入流

FileInputStream構造方法：

FileInputStream (String name);
FileInputStream （File file);

引數name和file指定的檔案稱作輸入流的源，輸入流通過呼叫read方法讀取源中的資料。
FileInputStream 輸入流開啟一個到達的檔案的輸入流（源就是這個檔案，輸入流指向這個檔案）

示例

import java.io.*;

public class FileStream3 {
    public static void main(String[] args) throws Exception {
        int n = -1;
        byte[] a = new byte[1000];//[100]or[1024]就是每次讀取的最大位元組數
        File file = new File("FileStream2.java");// 預設目錄下要有檔案
        //File file = new File("D:\\eclipse\\workspace\\IO\\src\\com\\file\\FileStream2.java");

        FileInputStream in = new FileInputStream(file);
        while((n=in.read(a,0,1000))!=-1){
            String s = new String(a,0,n);
            System.out.println(s);
        }
        in.close(); 
    }
}
//結果把 FileStream2.java內容輸出了

檔案位元組輸出流

FileOutputStream構造方法

FileOutputStream(String name)
FileOutputStream(File file)

示例

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/**
 * 檔案位元組輸入流
 * @author Peng
 *
 */
public class Fileoutputstream {
    public static void main(String[] args) {
        byte[] a ="江西理工 2016級新生報到".getBytes();
        byte[] b = "軍訓快樂".getBytes();
        try {
            FileOutputStream out = new FileOutputStream("happy.txt");
            out.write(a);
            System.out.println(b.length);
            out.write(b, 0, b.length);//out.write(b,4,4) 快樂
            out.close();

            /*讀取資料部分
            File file = new File("happy.txt");
            if(file.exists()){
                FileInputStream in = new FileInputStream(file);
                byte[] buffer = new byte[1024];
                int n =-1;
                while((n=in.read(buffer))!=-1){
                    System.out.println(new String(buffer,0,n));
                }
                in.close();
            }*/
        }catch (IOException e) {
            e.printStackTrace();
        }
    }
}

8
江西理工 2016級新生報到軍訓快樂

位元組流綜合示例

示例1

import java.io.*;

public class FileStream {
    public static void main(String[] args) throws Exception {
        FileOutputStream out = new FileOutputStream("hello.txt");//在目錄下新建hello.txt
        out.write("http://blog.csdn.net/peng_hong_fu/article/details/52605935".getBytes()); // 把字串轉化為位元組陣列並寫入到流中
        out.close();

        File f = new File("hello.txt");
        FileInputStream in = new FileInputStream(f);
        byte[] buf = new byte[1024];
        int len = in.read(buf); // 讀取內容到位元組陣列buf中
        System.out.println("len:"+len);
        System.out.println(new String(buf, 0, len)); // String建構函式把位元組陣列轉化為字串
        in.close();
    }
}
len:58
http://blog.csdn.net/peng_hong_fu/article/details/52605935

5 檔案字元流

位元組流不能很好的操作Unicode字元，一個漢字在檔案中佔有2個位元組，如果使用位元組流，讀取不當會出現”亂碼”現象

 FileReader(String filename); FileReader(File filename) 
 FileWriter(String filename); FileWriter(File filename)

示例1

import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class FileReaderWriter {
    public static void main(String[] args) {
        try {
            String content = "輕輕的我走了,正如我輕輕的來...000";
            File f = new File("ourang.txt");
            char[] a = content.toCharArray();
            FileWriter out = new FileWriter(f);
            out.write(a, 0, a.length);
            out.close();

            FileReader in = new FileReader(f);
            StringBuffer buffer = new StringBuffer();
            char[] tom = new char[10];
            int n = -1;
            while ((n = in.read(tom, 0, 10)) != -1) {
                String temp = new String(tom, 0, n);
                buffer.append(temp);
            }
            in.close();
            System.out.println(new String("內容:" + buffer));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

內容:輕輕的我走了,正如我輕輕的來...000

示例2

import java.io.*;

public class FileStream2 {
    public static void main(String[] args) throws Exception {
        FileWriter out = new FileWriter("hello2.txt");
        out.write("一句珍重！"); // 在此可以直接寫入字串，不用轉化為位元組陣列
        out.close();

        char[] buf = new char[1024]; // 字元陣列
        FileReader in = new FileReader("hello2.txt");
        int len = in.read(buf); // 此時的read方法可以讀取一個字元或幾個字元,len代表實際讀取到的字元的個數。
        System.out.println("len:" + len);
        System.out.println(new String(buf, 0, 1024)); // String建構函式把字元陣列轉化為字串。
        in.close();
    }
}
len:5
一句珍重！

6 快取流

BufferedReader類和BufferedWriter類建立的物件稱作緩衝輸入、輸出流，二者增強了讀寫檔案的能力，提供了讀取檔案一行的方法。

BufferedReader流和BufferedWriter流，二者的源和目的地都必須是字元輸入流和字元輸出流
BufferedReader類和BufferedWriter類的構造方法

BufferedReader (Reader in)
BufferedWriter (Writer out)

BufferedReader 流讀取文字行，readLine()

    FileReader inOne = new FileReader("Student.txt");
    BufferedReader inTwo = new BufferedReader(inOne);
    ....
    String strLine = inTwo.readLine();
    ..
    outTwo.newLine();// 寫入回行符

示例

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/**
 * BufferedReader and BufferedWriter
 * @author Peng
 */
public class BufferRW {
    public static void main(String[] args) {
        File file = new File("Studen.txt");
        String[] content = { "商品列表:", "電視機,2993元/臺", "洗衣機,3444元/臺", "冰箱,8444元/臺" };
        try {
            FileWriter outOne = new FileWriter(file);
            BufferedWriter outTwo = new BufferedWriter(outOne);
            for (String str : content) {
                outTwo.write(str);
                outTwo.newLine();// 寫入回行符
            }
            outTwo.close();// 注意關閉順序 先把快取流關閉
            outOne.close();

            // read
            FileReader inOne = new FileReader(file);
            BufferedReader inTwo = new BufferedReader(inOne);
            String s = null;
            while ((s = inTwo.readLine()) != null) {
                System.out.println(s);
            }
            inTwo.close();
            inOne.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

商品列表:
電視機,2993元/臺
洗衣機,3444元/臺
冰箱,8444元/臺

7 隨機流

既可以讀檔案也可以寫檔案的流，RandomAccessFile 類建立的流稱作隨機流。

RandomAccessFile 構造方法：

RandomAccessFile(String name,String mode) 引數name 檔名，mode r(只讀）或rw(可讀寫）

RandomAccessFile(File file,String mode)

方法

seek(long a) 定位RandomAccessFile 流的讀寫位置，a確認讀寫位置距離檔案開頭的位元組個數。

getFilePointer() 獲取流的當前讀寫位置。
readInt()  讀取一個int的值
readLine() 讀取一個文字行
.
.

示例

import java.io.IOException;
import java.io.RandomAccessFile;

public class MyRandomAccessFile {
    public static void main(String[] args) {
        RandomAccessFile inAndOut = null;
        int data[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
        System.out.println(data.length);
        try {
            inAndOut = new RandomAccessFile("tom.dat", "rw");
            for (int i = 0; i < data.length; i++) {
                inAndOut.writeInt(data[i]);
            }

            //read
            for (long i = data.length - 1; i >= 0; i--) {// 一個int型資料佔4個位元組,inAndOut從檔案的低36個位元組出開始讀取
                inAndOut.seek(i * 4); // 每隔4個字元往前讀取一個整數
                System.out.printf("\t%d", inAndOut.readInt());
            }
            inAndOut.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

10
    10  9   8   7   6   5   4   3   2   1

非ASCII字元亂碼

RandomAccessFile 流的readLine()方法在讀取非ASCII字元的檔案時（如漢字的檔案）會出現”亂碼”現象,可以有下面的操作

    //讀取
    String str = in.readLine();

    //用"iso-8859-1"重新編碼
    byte [] b =str.getBytes("iso-8859-1");

    //使用預設編碼，或指定編碼把位元組陣列轉化成字串
    String str2 = new String(b);
    //String str2 = new String(b,"GB2312");

示例

import java.io.IOException;
import java.io.RandomAccessFile;

public class MyRandomAccessFile亂碼 {
    public static void main(String[] args) {
        RandomAccessFile in = null;
        int data[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
        System.out.println(data.length);
        try {
            in = new RandomAccessFile("D:\\eclipse\\workspace\\IO\\src\\com"
                    + "\\file\\隨機流\\MyRandomAccessFile.java", "rw");//絕對路徑 指定目錄下檔案
            long length = in.length();
            long position = 0;
            in.seek(position);
            while(position<length){
                String str = in.readLine();
                byte [] b =str.getBytes("iso-8859-1");
                String str2 = new String(b);
                position = in.getFilePointer();
                //System.out.println(str);
                System.out.println(str2);
            }
            in.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

輸出str時亂碼

....
    for (long i = data.length - 1; i >= 0; i--) {// ????int????????4??×???,inAndOut??????????36??×?????????????
    inAndOut.seek(i * 4); // ????4??×?·??ù?°????????????
    ...

8 陣列流

流的源和目標是計算機記憶體

位元組陣列輸入流 ByteArrayInputStream 和位元組陣列輸出流 ByteArrayOutputStream

對應字元陣列流 CharArrayReader 和 CharArrayWriter

9 資料流

允許程式按著機器無關的風格讀取Java原始資料。

DateInputStream 和 DateOutputStream 資料輸入流和資料輸出流

示例

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Scanner;

public class PasswordTest {
    public static void main(String[] args) {
        String sourceString = "Kimi一路走好";
        EncryptAndDecrypt person = new EncryptAndDecrypt();
        System.out.println("輸入密碼加密:" + sourceString);
        Scanner scanner = new Scanner(System.in);
        String password = scanner.nextLine();
        String secret = person.encrypt(sourceString, password);
        File file = new File("secret.txt");
        try {
            FileOutputStream fos = new FileOutputStream(file);
            DataOutputStream outData = new DataOutputStream(fos);
            outData.writeUTF(secret);
        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println("密文:" + secret);
        // 解密
        System.out.println("輸入解密密碼:");
        password = scanner.nextLine();
        try {
            FileInputStream fis = new FileInputStream(file);
            DataInputStream inData = new DataInputStream(fis);
            String str = inData.readUTF();
            String mingwen = person.decrypt(str, password);
            System.out.println("解密命令:" + mingwen);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

輸入密碼加密:Kimi一路走好
Tiger
密文:????乲蹃跙姤
輸入解密密碼:
Tiger
解密命令:Kimi一路走好

10 物件流

ObjectInputStream 和ObjectOutputStream 類建立的物件稱作物件輸入流和物件輸出流。
有涉及物件序列化

    FileOutputStream fileOut = new FileOutputStream(file);
    ObjectOutputStream objectOut = new ObjectOutputStream(fileOut);

示例

TV.java

import java.io.Serializable;

public class TV implements Serializable{
    String name;
    int price;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getPrice() {
        return price;
    }
    public void setPrice(int price) {
        this.price = price;
    }

}

ObjectStream.java

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class ObjectStream {
    public static void main(String[] args) {
        TV TCL = new TV();
        TCL.setName("TCL電視");
        TCL.setPrice(5500);
        File file = new File("television.txt");
        try {
            FileOutputStream fileOut = new FileOutputStream(file);
            ObjectOutputStream objectOut = new ObjectOutputStream(fileOut);
            objectOut.writeObject(TCL);
            objectOut.close();

            FileInputStream fileIn = new FileInputStream(file);
            ObjectInputStream objectIn = new ObjectInputStream(fileIn);
            TV xiaomi = (TV) objectIn.readObject();
            objectIn.close();
            xiaomi.setName("小米電視");
            xiaomi.setPrice(2444);
            System.out.println("TCL的名字:" + TCL.getName());
            System.out.println("TCL的價格:" + TCL.getPrice());
            System.out.println("xiaomi的名字:" + xiaomi.getName());
            System.out.println("xiaomi的價格:" + xiaomi.getPrice());

        } catch (ClassNotFoundException e) {
            System.out.println("不能讀出物件");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

TCL的名字:TCL電視
TCL的價格:5500
xiaomi的名字:小米電視
xiaomi的價格:2444

11 序列化與物件克隆

A one = new A();
A two = one;
..
two.x = 100;//則one.x的值也是100

有時想得到物件的一個”複製品”,複製品的實體的變化不會引起原物件實體發生變化，反之亦然。這樣的複製品稱為 原物件的一個克隆物件。上個例子中的xiaomi 就是TCL的一個克隆。

當程式想比較快的速度獲取一個物件的克隆時，可以用物件流將物件的序列化資訊寫入記憶體中，而不是磁碟的檔案中。

    FileOutputStream fileOut = new FileOutputStream(file);
    ObjectOutputStream objectOut = new ObjectOutputStream(fileOut);
    和
    FileInputStream fileIn = new FileInputStream(file);
    ObjectInputStream objectIn = new ObjectInputStream(fileIn);

    替換為
    ByteArrayOutputStrem outByte = new ByteArrayOutputStream();
    ObjectOutputStream objectOut = new ObjectOutputStream(outByte);
    和
    ByteArrayInputStrem inByte = new ByteArrayInputStream();
    ObjectInputStream objectInt= new ObjectInputStream(inByte);

12 檔案鎖

java.io.channels 包中的FileLock 和FileChannel 類的物件實現檔案鎖操作。

示例

書中的程式，多次查詢後，會刪除檔案內容

import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.channels.FileChannel;
import java.nio.channels.FileLock;
import java.util.Scanner;
/**
 * 檔案鎖
 * @author Peng
 *
 */
public class MyFileLock {
    public static void main(String[] args) {
        File file = new File("FileStream2.java");//預設專案目錄下要有檔案
        Scanner scanner = new Scanner(System.in);
        try {
            RandomAccessFile input = new RandomAccessFile(file, "rw");
            FileChannel channel = input.getChannel();
            FileLock lock = channel.tryLock();// 加鎖
            System.out.println("輸入要讀取的行數:");
            while(scanner.hasNextInt()){
                int m = scanner.nextInt();
                lock.release(); //解鎖
                for(int i= 1;i<=m;i++){
                    String str = input.readLine();
                    System.out.println(str);
                }
                lock = channel.tryLock();   //加鎖
                System.out.println("輸入要讀取的行數:");
            }
        } catch (IOException e) {

        }
    }
}

輸入要讀取的行數:
2
package com.file.????×????÷;

輸入要讀取的行數:
3
import java.io.*;

public class Fileinputstream2 {
輸入要讀取的行數:
4
    public static void main(String[] args) throws Exception {
        int n = -1;
        byte[] a = new byte[1000];//[100]or[1024]??????????????×??ó×?????
        File file = new File("FileStream2.java");// ??????????????????
輸入要讀取的行數:
5
        //File file = new File("D:\\eclipse\\workspace\\IO\\src\\com\\file\\FileStream2.java");

        FileInputStream in = new FileInputStream(file);
        while((n=in.read(a,0,1000))!=-1){
            String s = new String(a,0,n);
輸入要讀取的行數:
6
            System.out.println(s);
        }
        in.close(); 
    }
}
null
輸入要讀取的行數:

7
null
null
null
null
null
null
null
輸入要讀取的行數:

相關推薦

Java筆記(7)-輸入、輸出流、File類、InputStream、Reader、檔案位元組流、檔案字元流、緩衝流、隨機流、資料流、物件流、序列化和物件克隆、Scanner解析檔案、Console流

所有的合適都是兩個人的相互遷就和改變，沒有天生合適的兩個人，兩個人朝著相同的方向努力，就是最好的愛情。 輸入、輸出流 什麼是“流”。直觀地講，流就像水一樣，不存在大小問題，也避免了完整性問題。非流的資料傳輸，比如你下載一張圖片，需要整幅圖片下

XmlSerializer 物件的Xml序列化和反序列化

這篇隨筆對應的.Net名稱空間是System.Xml.Serialization；文中的示例程式碼需要引用這個名稱空間。 為什麼要做序列化和反序列化？ .Net程式執行時，物件都駐留在記憶體中；記憶體中的物件如果需要傳遞給其他系統使用；或者在關機時需要儲存下來以便下次再次啟

java 物件序列化和物件反序列化操作時的版本相容性問題

當你一個類實現了Serializable介面，如果沒有定義serialVersionUID，Eclipse會提供這個提示功能告訴你去定義 。在Eclipse中點選類中warning的圖示一下，Eclipse就會自動給定兩種生成的方式。如果你沒有考慮到相容性問題時，就把它關掉，不過有這個功能是好的，只要任何類別

Java基礎之IO流（位元組流、字元流、記憶體流、帶快取的流、序列化和反序列化）

File類：File類提供了對檔案的操作，可以通過字串或URI來構建一個File類物件。通過物件，可以實現檔案的建立（createNewFile）、刪除（delete）、獲得檔名（getName）、獲得父目錄物件（getParentFile）、獲得父目錄名稱（

java IO 位元組流、字元流操作總結三之字元流、序列化和反序列化

這一篇我講介紹一下字元流。什麼是字元流，就是若干個位元組組成一個字元。（為什麼說是若干個，不能確定嗎）這裡就來說說原因和編碼問題。 首先說說字元編碼的問題，比較常用的編碼有gbk,utf-8等。 a、.編碼問題（看前面所描述的）。 1、gbk 編碼中文佔用2個位元組，英文

java基礎之序列化 Java物件表示方式1：序列化、反序列化和transient關鍵字的作用

轉載自https://www.cnblogs.com/szlbm/p/5504166.html     Java物件表示方式1：序列化、反序列化和transient關鍵字的作用   平時我們在Java記憶體中的物件，是無 法進行IO操作或者網路通訊的

python中的檔案流、序列化以及反序列化（物件流）：

1.檔案流：    語法：        file_object = open(file_name, access_mode = ‘r’, buffering = -1)        open函式有很多的引數，常用的是file_name，mode和encoding     

Java-裝飾流-物件流 - 序列化和反序列化

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

IO流（File類，IO流的分類，位元組流和字元流，轉換流，緩衝流，物件序列化）

1.File類 File類可以在程式中 操作檔案和目錄。File類是通過建立File類物件，在呼叫File類的物件來進行相關操作的。 示例： --------------------- 本文來自 dajiahuooo 的CSDN 部落格 ，全文地址請點選：https://blog.csdn.net/

Java之IO學習(二)物件操作（序列化、反序列化）

1、內容 序列化就是將物件轉換成位元組序列，方便儲存和轉換 ObjectInputStream--readObject(): 讀入物件,反序列化 ObjectOutputStream--writeO

JAVA_TOJAVASE_Day0809（面向物件,陣列工具的建立和物件繼承、單例設計模式、抽象類）

面向物件,陣列工具的建立和物件繼承 優化： package com.ttzx.study.utils; /** * 建立一個用於運算元組的工具類，其中包含著常見的對陣列操作的函式，如：最值排序等。 * @author 子龍 * @version V1.0 *

java基礎序列化、反序列化和transient的作用

一、概念為什麼會有序列化？平時我們所說的java記憶體中的物件是無法進行網路通訊和IO操作的，物件將以序列化的儲存狀態（表現形式）被它們所識別。序列化：將一個物件轉換成一串二進位制表示的位元組陣列，通過儲存或轉移這些位元組陣列達到持久化的目的。反序列化：將位元組陣列重組成物件

javaSE-IO補充 功能流物件（序列化和瞬態關鍵字）

/* * 列印流：PrintStream * 特點： * 1，給位元組輸出流提供了列印方法。 * 2，方便列印數值表示形式。 * 3，建構函式接收File物件，字串路徑，OutputStream. */ PrintStream ps = new PrintStr

python基礎之繼承組合應用、對象序列化和反序列化，選課系統綜合示例

sel 初始 否則 通用 __init__ period 類型 反序列化 信息 繼承+組合應用示例 1 class Date: #定義時間類，包含姓名、年、月、日，用於返回生日 2 def __init__(self,name,year,mon,day):

Python學習心得(五) random生成驗證碼、MD5加密、pickle與json的序列化和反序列化

用法 div com ict file imp randint csdn == # -*- coding:utf-8 -*- import random as rd #驗證碼 import hashlib as hsl #MD5加密 import pickle,json

java中的序列化和反序列化學習筆記

文件 track 反序列化 out val nts 鼠標 main version 須要序列化的Person類： package cn.itcast_07; import java.io.Serializable; /* * NotSerializableE

python3 中的Json序列化、反序列化 和 字符編碼的問題解決

ron bsp port imp 入參 oos elf asc 反序列化 python3在通過Json往文件裏寫內容時中文字符被轉成unicode編碼 import json class file_open(object): f = open(‘c

Django Restful Framework【第四篇】版本、解析器、序列化和請求數據驗證

tor ade clu cts scheme com 繼承 src 當前 一、版本 程序也來越大時，可能通過版本不同做不同的處理 沒用rest_framework之前，我們可以通過以下這樣的方式去獲取。 class UserView(APIView): def

文件流的使用以及序列化和反序列化的方法使用

不能 引入 創建 exist files 文件流對象 des file 列表 步驟一：引入IO文件和二進制格式序列化文件using System.IO;using System.Runtime.Serialization.Formatters.Binary;步驟二：將圖書對

二進位制流序列化(反序列化)和XML序列化(反序列化)

序列化（Serialization）：序列化是將物件狀態轉換為可儲存或傳輸的其它資料格式的過程。 反序列化(Deserialization) ：與序列化相對的是反序列化，將其它資料格式轉換為物件的過程。 作用：將物件中的資料轉換成其它檔案，方便資訊的儲存與交換。  .NET