JAVA中文件的讀寫 I/O 輸入輸出流

主要內容

1.編碼問題

2.File類的使用

3.RandomAccessFile的使用

4.I/O 輸入輸出流

編碼問題：

import java.io.UnsupportedEncodingException;

public class 編碼問題 {
    public static void main(String[] args) {
        // 我們項目的默認編碼是GBK
        String s = "測試 ABC";
        byte[] byte1 = s.getBytes();// 轉換成的字節序列用的是項目默認的編碼gbk
        for (byte b : byte1) {
            // 1 byte = 8 位 //toHexString這個函數是把字節（轉換成了Int）以16進制的方式顯示
            System.out.print(Integer.toHexString(b & 0xff) + " ");// &
                                                                    // 0xff是為了把前面的24個0去掉只留下后八位
        }

        try {
            // 也可以轉換成指定的編碼
            byte[] bytes1 = s.getBytes("gbk");
            System.out.println(new String(bytes1));
        } catch (UnsupportedEncodingException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        /**
         * gbk編碼： 中文占用兩個字節，英文占用一個字節 utf-8編碼：中文占用三個字節，英文占用一個字節
         * java是雙字節編碼，是utf-16be編碼 utf-16be編碼：中文占用兩個字節，英文占用兩個字節
         * 當你的字節序列是某種編碼時，這個時候想把字節序列變成字符串，也需要用這種編碼方式，否則會出現亂碼
         */
        try {
            byte[] byte2 = s.getBytes("utf-16be");
            String s2 = new String(byte2, "utf-16be");
            System.out.println(s2);
        } catch (UnsupportedEncodingException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        /**
         * 文本文件就是字節序列，可以是任意編碼的字節序列
         * 如果我們在中文機器上直接創建文本文件，那么該文件只認識ANSI編碼（例如直接在電腦中創建文本文件）
         */

        /**
         * byte轉int的時候為什么非要先&0xff計算出來才是正確答案？
         * 首先，java中的二進制采用的是補碼形式，並非原碼或反碼，這3個概念要搞清楚；
         * 其次，byte占8位，int占32位，將byte強制轉換為int型時，如果沒有做 &
         * 0xff運算，且byte對應的值為負數的話，就會對高位3個字節進行補位，這樣就有可能出現補位誤差的錯誤。
         * 舉例來說，byte型的-1，其二進制（補碼）為11111111（即0xff），轉換成int型，值也應該為-1，但經過補位后，
         * 得到的二進制為11111111111111111111111111111111（即0xffffffff），這就不是-1了，對吧？
         * 而0xff默認是int型，所以，一個byte跟0xff相與，會先將那個byte轉化成int型運算，這樣，結果中的高位3個字節就總會被清0，
         * 於是結果就是我們想要的了~
         */

    }

}

File類的使用：

JAVA.io.File類用於表示文件（目錄）

File類只用於表示文件（ 目錄）的信息（名稱、大小等），不能用於文件內容的訪問

File類的常用API：

1.創建File對象：File file=new File(String path);注意：File.seperater();獲取系統分隔符，如：”\“.

2.boolean file.exists();是否存在.

3.file.mkdir();或者file.mkdirs();創建目錄或多級目錄。

4.file.isDirectory()或者file.isFile()判斷是否是目錄或者是否是文件。

5.file.delete();刪除文件或目錄。

6.file.createNewFile();創建新文件。

7.file.getName()獲取文件名稱或目錄絕對路徑。

8.file.getAbsolutePath()獲取絕對路徑。

9.file.getParent();獲取父級絕對路徑。

10.file.getSize();獲取文件大小。

11.file.getFormat();獲取文件格式名。

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

public class FileDemo {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // 了解構造函數的情況 查幫助ALT+/
        File file = new File("E:\\javaio\\imooc");
        // 判斷文件/文件夾是否存在
        // System.out.println(file.exists());
        if (!file.exists())
            file.mkdir(); // file.mkdirs()如果文件不存在，直接創建文件夾
        // mkdir創建的一級目錄，如果需要創建多級目錄可以使用mkdirs()
        else
            file.delete();

        // 是否是一個目錄 如果是目錄返回true,如果不是目錄or目錄不存在返回的是false
        System.out.println(file.isDirectory());
        // 是否是一個文件
        System.out.println(file.isFile());

        // File file2 = new File("e:\\javaio\\日記1.txt");
        File file2 = new File("e:\\javaio", "日記1.txt");
        if (!file2.exists())
            try {
                file2.createNewFile();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        else
            file2.delete();
        // 常用的File對象的API
        System.out.println(file);// file.toString()的內容
        System.out.println(file.getAbsolutePath());
        System.out.println(file.getName());
        System.out.println(file2.getName());
        System.out.println(file.getParent());
        System.out.println(file2.getParent());
        System.out.println(file.getParentFile().getAbsolutePath());
    }

}

遍歷目錄

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

//列出File的一些常用操作比如過濾，遍歷等操作
public class FileUtils {
    /**
     * 列出指定指定目錄下(包括其子目錄)的所有文件
     * 
     * @param dir
     * @throws IOException
     */
    public static void listDirectory(File dir) throws IOException {
        if (!dir.exists()) {
            throw new IllegalArgumentException("目錄:" + dir + "不存在");
        }
        if (!dir.isDirectory()) {
            throw new IllegalArgumentException(dir + "不是目錄");
        }

        // String[] fileNames =
        // dir.list();//返回的是字符串數組，list()方法用於列出當前目錄下的子目錄和文件，直接子的名稱，不包含子目錄下的內容
        // for (String string : fileNames) {
        // System.out.println(dir+"\\"+string);
        // }
        //
        // 如果要遍歷子目錄下的內容就需要構造成File對象做遞歸操作,File提供了直接返回File對象的API
        File[] files = dir.listFiles();// 返回的是直接子目錄(文件)的抽象
        if (files != null && files.length > 0) {// 確定存在子目錄
            for (File file : files) {
                if (file.isDirectory()) {
                    // 遞歸
                    listDirectory(file);
                } else {
                    System.out.println(file);
                }
            }
        }
    }
}

RandomAccessFile的使用

RandomAccessFile JAVA提供的對文件內容的訪問，既可以讀文件，也可以寫文件。

RandomAccessFile支持隨機訪問文件，可以訪問文件的任意位置

(1)JAVA文件模型

在硬盤上的文件是byte byte byte存儲的,是數據的集合

(2)打開文件

有兩種模式"rw"(讀寫) "r"（只讀)

RandomAccessFile raf = new RandomeAccessFile(file,"rw")

文件指針，打開文件時指針在開頭 pointer = 0;

(3) 寫方法

raf.write(int)--->只寫一個字節（后8位),同時指針指向下一個位置，准備再次寫入

提供和很多方法能夠一次讀寫一個基本類型的數據

(4)讀方法

int b = raf.read()--->讀一個字節

(5)文件讀寫完成以后一定要關閉（Oracle官方說明）

import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.util.Arrays;

public class RafDemo {

    /**
     * @param args
     */
    public static void main(String[] args) throws IOException {
        File demo = new File("demo");
        if (!demo.exists())
            demo.mkdir();
        File file = new File(demo, "raf.dat");
        if (!file.exists())
            file.createNewFile();

        RandomAccessFile raf = new RandomAccessFile(file, "rw");
        // 指針的位置
        System.out.println(raf.getFilePointer());

        raf.write('A');// 只寫了一個字節
        System.out.println(raf.getFilePointer());
        raf.write('B');

        int i = 0x7fffffff;
        // 用write方法每次只能寫一個字節，如果要把i寫進去就得寫4次
        raf.write(i >>> 24);// 高8位
        raf.write(i >>> 16);
        raf.write(i >>> 8);
        raf.write(i);
        System.out.println(raf.getFilePointer());

        // 可以直接寫一個int
        raf.writeInt(i);

        String s = "中";
        byte[] gbk = s.getBytes("gbk");
        raf.write(gbk);
        System.out.println(raf.length());

        // 讀文件，必須把指針移到頭部
        raf.seek(0);
        // 一次性讀取,把文件中的內容都讀到字節數組中
        byte[] buf = new byte[(int) raf.length()];
        raf.read(buf);

        System.out.println(Arrays.toString(buf));
        for (byte b : buf) {
            System.out.println(Integer.toHexString(b & 0xff) + " ");
        }
        raf.close();
    }

}

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

public class RafReadDemo {

    /**
     * @param args
     */
    public static void main(String[] args) throws IOException {
        // TODO Auto-generated method stub
        RandomAccessFile raf = new RandomAccessFile("demo/raf.dat", "r");
        raf.seek(2);
        int i = 0;
        int b = raf.read();// 讀取到一個字節
        System.out.println(raf.getFilePointer());
        i = i | (b << 24);
        b = raf.read();
        i = i | (b << 16);
        b = raf.read();
        i = i | (b << 8);
        b = raf.read();
        i = i | b;
        System.out.println(Integer.toHexString(i));
        raf.seek(2);
        i = raf.readInt();
        System.out.println(Integer.toHexString(i));
        raf.close();
    }
}

序列化與基本類型序列化

1）將類型int 轉換成byte或將其他數據類型轉換成byte的過程叫序列化

數據---->n byte

2)反序列化

將n個byte 轉換成一個數據的過程

nbyte ---> 數據

3)RandomAccessFile提供基本類型的讀寫方法，可以將基本類型數據

序列化到文件或者將文件內容反序列化為數據

import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
public class RandomAccessFileSeriaDemo {

    /**
     * @param args
     */
    public static void main(String[] args) throws IOException {
        // TODO Auto-generated method stub
        File demo = new File("demo1");
        if (!demo.exists())
            demo.mkdir();
        File file = new File(demo, "raf.dat");
        if (!file.exists())
            file.createNewFile();
        // 打開文件，進行隨機讀寫
        RandomAccessFile raf = new RandomAccessFile(file, "rw");
        /* 序列化 */
        int i = 0x7ffffff;
        raf.write(i >>> 24);
        raf.write(i >>> 16);
        raf.write(i >>> 8);
        raf.write(i);
        System.out.println(raf.getFilePointer());

        /* 反序列化 */
        raf.seek(0);
        int b = raf.read();
        i = i | (b << 24);
        b = raf.read();
        i = i | (b << 16);
        b = raf.read();
        i = i | (b << 8);
        b = raf.read();
        i = i | b;
        System.out.println(Integer.toHexString(i));
        raf.close();
    }
}

RandomAccessFileSeriaDemo

I/O 輸入輸出流

流的定義：

流就是程序和設備之間嫁接起來的一根用於數據傳輸的管道，這個管道上有很多按鈕，不同的按鈕可以實現不同的功能。

這根用於數據傳輸的管道就是流，流就是一根管道

輸入時，程序在源(文件，網絡，內存)上打開一個流，然后如圖一個一個順序讀。寫也一樣。

流的分類和使用：

四大基本抽象流，文件流，緩沖流，轉換流，數據流，Print流，Object流。

JAVA.io 包中定義了多個流類型(類或抽象類)來實現輸入/輸出功能；可以從不同角度對其進行分類：

*按數據流的方向不用可以分為輸入流和輸出流

*按處理數據單位不同可以分為字節流和字符流

*按照功能不同可以分為節點流和處理流

JAVA中所提供的的所有流類型位於包JAVA.io內，都分別繼承自以下四種抽象流類型：

節點流與處理流：

節點流可以從一個特定的數據源(節點)讀取數據(如：文件，內存)

處理流是“連接”在已存在的流(節點流或處理流)之上，通過對數據的處理為程序提供更為強大的讀寫功能。

節點流也叫原始流，處理流也叫包裹流。

 

流與類的關系：

如果一個類是用作設備和程序之間的數據傳輸，則這個類有一個新的名字叫做流

流一定是類，但類不一定是流

 

四大基本流的介紹

輸入流，輸出流，字節流，字符流

InputStream和OutputStream讀寫數據的單位是一個字節

Reader和Writer讀寫數據的單位是一個字符

在JAVA中一個字符占兩個字節

InputStream，OutputStream，Reader，Writer都是抽象類，或者說都是抽象流，通常我們使用的都是它們的子類，凡是以Stream結尾的都是字節流。

 

InputStream 流中的常用方法：

 

 

OutputStream 流中的常用方法：

 

Reader 流中的常用方法：

 

 Writer 流中的常用方法：

 

 

文件流

 文件流包括：

FileInputStream FileOutputStream --字節流

FileReader FileWriter --字符流

實例：讀取一個文件的內容並將其輸出到顯示器上，並統計讀取的字節個數

/*
    利用FileReader流來讀取一個文件中的數據，並在顯示器上輸出!
*/

import java.io.*;

public class TestFileReader {
    public static void main(String[] args) {
        FileReader fr = null;

        try {
            fr = new FileReader("C:\\Documents and Settings\\others\\桌面\\java\\TestFileReader.java");
            int cnt = 0;
            int ch;

            while (-1 != (ch = fr.read())) // 20行
            {
                System.out.print((char) ch); // System.out.print(int ch);
                                                // 這是在顯示器上輸出ch的整數值，所以必須的進行類型轉化，我們需要輸出的是ch所代表的整數對應的字符
                ++cnt;
            }

            System.out.printf("總共從TestFileReader.java文件中讀取了%d個字符", cnt);
        } catch (FileNotFoundException e) {
            System.out.println("找不到文件!");
            System.exit(-1);
        } catch (IOException e) {
            System.out.println("文件讀取失敗!");
            System.exit(-1);
        }
    }
}

 

FileInputStream的使用

 

FileReader的使用

字節流與字符流的區別：

FileInputStream 和FileOutputStream 可以完成所有格式文件的復制

FileReader和FileWriter只可以完成文本文件的復制，卻無法完成其他格式文件的復制

因為字節是不需要解碼和編碼的，將字節轉化為字符才存在解碼和編碼的問題

字節流可以從所有格式的設備中讀寫數據，但字符流只能從文本格式的設備中讀寫數據

實例：編程實現文件的復制

/*
    利用FileInputStream 和 FileOutputStream 可以完成所有格式文件的賦值
    因為字節是不需要解碼和編碼的，將字節轉化為字符才存在解碼的問題
    本程序完成了音頻文件的復制
*/

import java.io.*;

public class TestFileInputStreamOutputStreamCopy {
    public static void main(String[] args) {
        FileInputStream fi = null;
        FileOutputStream fo = null;

        try {
            fi = new FileInputStream("E:\\綜藝\\歌曲\\卡農.mp3");
            fo = new FileOutputStream("d:/share/Output.txt"); //使用播放器可正常播放該文件
            int ch;

            while (-1 != (ch = fi.read())) {
                fo.write(ch);
            }
        } catch (FileNotFoundException e) {
            System.out.println("文件沒有找到!");
            System.exit(-1);
        } catch (IOException e) {
            System.out.println("文件讀寫錯誤!");
            System.exit(-1);
        } finally {
            try {
                if (null != fi) {
                    fi.close();
                    fi = null;
                }
                if (null != fo) {
                    fo.close();
                    fo = null;
                }
            } catch (Exception e) {
                e.printStackTrace();
                System.exit(-1);
            }
        }

        System.out.println("文件復制成功!");
    }
}

/*
    本程序證明了 FileReader 和 FileWriter 只可以完成文本文件的復制，
            卻無法完成音頻格式文件的復制
*/

import java.io.*;

public class TestFileReaderWriterCopy {
    public static void main(String[] args) {
        FileReader fi = null;
        FileWriter fo = null;

        try {
            fi = new FileReader("E:\\綜藝\\歌曲\\卡農.mp3");
            fo = new FileWriter("d:/share/Output.txt"); // Output.txt使用播放器打開失敗！
                                                        // 本程序證明了FileWriter 和
                                                        // FileReader
                                                        // 無法完成音頻文件的復制，實際上FileWriter
                                                        // 和 FileReader
                                                        // 只能完成文本文件的復制
            int ch;

            while (-1 != (ch = fi.read())) {
                fo.write(ch);
            }
        } catch (FileNotFoundException e) {
            System.out.println("文件沒有找到!");
            System.exit(-1);
        } catch (IOException e) {
            System.out.println("文件讀寫錯誤!");
            System.exit(-1);
        } finally {
            try {
                if (null != fi) {
                    fi.close();
                    fi = null;
                }
                if (null != fo) {
                    fo.close();
                    fo = null;
                }
            } catch (Exception e) {
                e.printStackTrace();
                System.exit(-1);
            }
        }

        System.out.println("文件復制成功!");
    }
}

 

緩沖流

緩沖流就是帶有緩沖區的輸入輸出流

緩沖流可以顯著的減少我們對IO訪問的次數，保護我們的硬盤

緩沖流本事就是處理流(包裹流)，緩沖流必須得依附於節點流(原始流)

處理流包裹在原始節點流上的流，相當於包裹在管道上的管道

 

緩沖流要"套接"在相應的節點流之上，對讀寫的數據提供了緩沖的功能，提高了讀寫的效率，同時增加了一些新的方法。JAVA提供了四種緩沖流，其常用的構造方法為：

 

BufferedOutputStream 和 BufferedInputStream

BufferedOutputStream ：帶有緩沖的輸出流，允許一次向硬盤寫入多個字節的數據。

BufferedInputStream：帶緩沖的輸入流，允許一次向程序中讀入多個字節的數據。

BufferedOutputStream 和 BufferedInputStream都是包裹流，必須依附於OutputStream和InputStream

例子：利用BufferedOutputStream 和 BufferedInputStream 完成大容量文件的復制，這遠比單純利用FileInputStream和FileOutputStream要快的多

/*
    利用BufferedOutputStream 和 BufferedInputStream完成大容量文件的復制
    這遠比單純利用 FileInputStream  和 FileOutputStream 要快得多

    BufferedOutputStream 和 BufferedInputStream 都是包裹流，必須的依附於
    InputStream 和 OutputStream 
*/

import java.io.*;

public class TestBufferedInputStreamOutputStreamCopy {
    public static void main(String[] args) {
        BufferedOutputStream bos = null;
        BufferedInputStream bis = null;

        try {
            bos = new BufferedOutputStream(new FileOutputStream("e:/OutputView.txt")); // bos
                                                                                        // 輸出流有個默認的緩沖區，大小為32個字節

            bis = new BufferedInputStream(new FileInputStream("c:\\[高清在線www.66ys.cn]海底總動員DVD中英字幕.rmvb")); // bis
                                                                                                            // 輸入流有個默認的緩沖區，大小為32個字節
            byte[] buf = new byte[1024];
            int len = bis.read(buf, 0, 1024); // 一定要注意，這不是從buf中讀數據，而是從bis所關聯到的D:\\綜藝\\電影\\貓和老鼠\\CD4.rmvb文件中讀取數據，並將讀取的數據寫入bis自己的默認緩沖區中，然后再將緩沖區的內容寫入buf數組中，每次最多向buf數組中寫入1024個字節，返回實際寫入buf數組的字節個數，如果讀到了文件的末尾，無法再向buf數組中寫入數據，則返回-1
            while (-1 != len) {
                bos.write(buf, 0, len); // 不是寫入buf數組，而是將buf數組中下標從0開始的到len-1為止的所有數據寫入bos所關聯到的"d:/share/OutputView.txt"文件中
                len = bis.read(buf); // bis.read(buf); 等價於 bis.read(buf, 0,
                                        // buf.length);
            }
            bos.flush();
            bis.close();
            bos.close();
        } catch (FileNotFoundException e) {
            System.out.println("沒有找到文件!");
            System.exit(-1);
        } catch (IOException e) {
            System.out.println("文件讀寫錯誤!");
            System.exit(-1);
        }

        System.out.println("文件復制成功!");
    }
}

/*
    本程序讀寫速度要慢於  "TestBufferedInputStreamOutputStreamCopy.java" 程序
    即：
    利用BufferedOutputStream 和 BufferedInputStream完成大容量文件的復制
    這遠比單純利用 FileInputStream  和 FileOutputStream 要快得多

    BufferedOutputStream 和 BufferedInputStream 都是包裹流，必須的依附於
    OutputStream  和 OutputStream 
*/

import java.io.*;

public class TestBufferedInputStreamOutputStreamCopy_2 {
    public static void main(String[] args) {
        FileOutputStream bos = null;
        FileInputStream bis = null;

        try {
            bos = new FileOutputStream("e:/OutputView.txt");
            bis = new FileInputStream("c:\\[高清在線www.66ys.cn]海底總動員DVD中英字幕.rmvb");

            byte[] buf = new byte[1024];
            int len = bis.read(buf, 0, 1024);
            while (-1 != len) {
                bos.write(buf, 0, len);
                len = bis.read(buf);
            }
            bos.flush();
            bis.close();
            bos.close();
        } catch (FileNotFoundException e) {
            System.out.println("沒有找到文件!");
            System.exit(-1);
        } catch (IOException e) {
            System.out.println("文件讀寫錯誤!");
            System.exit(-1);
        }

        System.out.println("文件復制成功!");
    }
}

一定要注意，bis.read(buf,0,1024)；這不是從buf中讀數據，而是從bis所關聯到的“D:\\綜藝\\電影\\貓和老鼠\\CD4.rmvb”文件中讀取數據，並將讀取的數據寫入bis自己的默認緩沖區中，然后再將緩沖區的內容寫入buf數組中，每次最多向buf數組中寫入1024個字節，返回實際寫入buf數組的字節個數，如果讀到了文件的末尾，無法再向buf數組中寫入數據，則返回-1

BufferedInputStream流中有public int read(byte[] b)方法用來把從當前流關聯到的設備中讀取出來的數據存入一個byte數組中

BufferedOutputStream 流中有public int write(byte[] b)方法用來把byte數組中的數據輸出來當前流所關聯到的設備中

如果我們希望用BufferedInputStream 和 BufferedOutputStream 完成“將一個設備中的數據導入另一個設備中”，我們就應該定義一個臨時的byte類型的數據，用這個臨時數組作為輸入流和輸出流進行交互的中轉樞紐。

 

BufferedReader 和 BufferedWriter

 

實例：利用BufferedReader 和 BufferedWriter完成文本文件的復制

/*
    利用 BufferedReader 和 BufferedWriter 完成文本文件的復制
*/
import java.io.*;

public class TestBufferedReaderWriterCopy {
    public static void main(String[] args) {
        BufferedReader br = null;
        BufferedWriter bw = null;

        try {
            br = new BufferedReader(
                    new FileReader("C:\\Documents and Settings\\others\\桌面\\java\\TestBufferedReaderWriterCopy.java"));
            bw = new BufferedWriter(new FileWriter("d:/share/Writer.txt"));
            String str = null;

            while (null != (str = br.readLine())) // br.readLine()讀取一行字符，但會將讀取的換行符自動丟棄,即返回的String對象中並不包括換行符
            {
                bw.write(str);
                bw.newLine(); // 寫入一個換行符 這行不能省
            }
            bw.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            System.exit(-1);
        } catch (IOException e) {
            e.printStackTrace();
            System.exit(-1);
        } finally {
            try {
                bw.close();
                br.close();
            } catch (IOException e) {
                e.printStackTrace();
                System.exit(-1);
            }
        }
    }
}

 

數據流DataInputStream DataOutputStream

DataInputStream能夠以一種與機器無關的方式，直接從底層字節輸入流讀取JAVA基本類型和String類型的數據。常用方法包括：

DataInputStream 是包裹流，必須依附於InputStream

DataOutputStream能夠以一種機器無關的方式，直接將JAVA基本類型和String類型數據寫出到其他的字節輸出流。常用方法包括：

DataOutputStream 是包裹流，它必須依附於OutputStream

數據流實例：

編程實現將long類型數據寫入byte數組，然后再從byte數組中吧該數據讀出來{

　　*這是Socket編程中經常要完成的功能。

　　*因為網絡編程中經常要把數據存入byte數組中，然后把byte數組打包成數據包(DatagramPacket)，再把數據包經過網絡傳輸到目的機，目的機再從byte數組中把原數值型數據還原回來。

}

本程序要使用到：

DataInputStream 

DataOutputStream

ByteArrayInputStream

ByteArrayOutputStream

/*
    功能：把一個long類型的數據寫入byte數組中,然后再從byte數組中讀取出
          這個long類型的數據
          
          因為網絡編程中經常要把數值型數據存入byte數組中然后打包成
          DatagramPacket經過網絡傳輸到目的機，目的機再從byte數組中
          把原數值型數據還原回來
    
    目的: ByteArrayOutputStream   DataOutputStream  ByteInputStream DataInputStream 流的使用
          記住: DataOutputStream流中的writeLong(long n)是把n變量在內存
                  中的二進制代碼寫入該流所連接到的設備中
                  
    注意：查API文檔得知：
            構造  ByteArrayOutputStream 對象時不需要也不能指定緩沖數組，因為緩沖數組默認已經內置好了         
              構造  ByteArrayInputStream 對象時必須的指定緩沖數組是誰！
*/

import java.io.*;

public class TestByteArrayOutputStream1
{
    public static void main(String args[]) throws Exception
    {
        long n = 9876543210L;
        ByteArrayOutputStream baos = new ByteArrayOutputStream();  //9行  API:"public ByteArrayOutputStream(): 創建一個新的 byte 數組輸出流。緩沖區的容量最初是 32 字節，如有必要可增加其大小。 "
                                    //9行代碼一旦執行完畢，意味着兩點: 1、在內存中生成了一個大小為32個字節的byte數組   2、有一根叫做baos的管道已鏈接到了該byte數組中，並且可以通過這個管道向該byte數組中寫入數據
                                    //雖然此時可以通過baos向baos所連接到的在內存中分配好的byte數組中寫入數據，但是ByteArrayOutputStream流並沒有提供可以直接把long類型數據直接寫入ByteArrayOutputStream流所連接到的byte數組中的方法, 簡單說我們沒法通過baos向baos所連接到的byte數組中寫入long類型的數據, 查API文檔可以發現: ByteArrayOutputStream流中並沒有類似writeLong()這樣的方法，但是DataOutputStream流中卻有writeLong() writeFloat()等方法
        DataOutputStream dos = new DataOutputStream(baos);
        
        dos.writeLong(n);  //把n變量所代表的10000L在內存中的二進制代碼寫入dos所依附的baos管道所連接到的內存中的大小為32字節的byte數組中，由運行結果來看，這是二進制寫入，既不是把10000L轉化為字符'1' '0' '0' '0' '0'寫入byte數組中，而是把10000L在內存中的總共8個字節的二進制代碼寫入byte數組中
        
        dos.flush();
        byte[] buf = baos.toByteArray();  //DataOutputStream 流中並沒有toByteArray()方法，但是ByteArrayOutputStream 流中卻有toByteArray()方法, 所以不可以把baos 改為dos，否則編譯時會出錯! ByteArrayOutputStream流中toByteArray()方法的含義，摘自API“創建一個新分配的 byte 數組。其大小是此輸出流的當前大小，並且緩沖區的有效內容已復制到該數組中”

        //利用ByteArrayInputStream 和 DataInputStream 可以從byte數組中得到原long類型的數值10000L
        ByteArrayInputStream bais = new ByteArrayInputStream(buf);
        DataInputStream dis = new DataInputStream(bais);
        long l = dis.readLong();

        System.out.println("l = " + l);
        dos.close();
    }
}
/*
    在JDK 1.6中的運行結果是：
----------------
l = 9876543210
----------------
*/

/*
    功能:
        將long類型數據寫入byte數組，然后在從byte數組中把該數據讀出來
*/

import java.io.*;

public class TestByteArrayOutputStream2
{
    public static void main(String[] args) throws Exception
    {
        long n = 1234567;
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        DataOutputStream dos = new DataOutputStream(baos);
        dos.writeLong(n);
        
        byte[] buf = baos.toByteArray();
        ByteArrayInputStream bis = new ByteArrayInputStream(buf);
        DataInputStream dis = new DataInputStream(bis);
        long n2 = dis.readLong();
        System.out.println("n2 = " + n2);
        
        dos.close(); 
        dis.close();
    }
}

 

轉換流：OutputStreamWriter InputStreamReader

OutputStreamWriter 流是把OutputStream流 轉化成Writer流的流

InputStreamReader 流是把InputStream流轉化為Reader

OutputStreamWriter 和 InputStreamReader都是包裹流

實例：如何將鍵盤輸入的字符組成字符串直接賦給String對象。

/*
    如何將鍵盤輸入的字符組成字符串直接賦給String 對象
    
    預備知識:
--------------------------------
Reader FileReader InputStream FileInputStream BufferedInputStream 
流中都沒有 readLine 方法
    DataInputStream 流中有 readLine方法，但已經 被標記為過時
    BufferedReader 流中有readLine方法，並且該方法是可以正確被使用的
--------------------------------
*/

import java.io.*;

public class TestStringInput
{
    public static void main(String[] args) 
    {
        String str = null;
        BufferedReader br = new BufferedReader (   //21行
                    new InputStreamReader(System.in)
                ); //23行  查API：從21行到23行的代碼是不會拋出任何異常的
                
        try
        {
            str = br.readLine(); //會拋出IOException異常
        }
        catch (IOException e)
        {
            e.printStackTrace();
            System.exit(-1);
        }    
        
        System.out.println("str = " + str);        
        try
        {
            br.close(); //會拋出IOException異常
        }
        catch (IOException e)
        {
            e.printStackTrace();
            System.exit(-1);
        }        
    }
}
/*
    在JDK 1.6中的運行結果是：
--------------------------------
sadd行政村123Asd?asd撒旦
str = sadd行政村123Asd?asd撒旦
--------------------------------
*/

 

readLine()與回車符的問題：

 

Print流  PrintWriter PrintStream

Print 流只有輸出，沒有輸入

分類：

PrintWriter輸入字符

PrintStream輸出字符

 

PrintWriter在OutputStream基礎之上提供了增強的功能，既可以方便地輸出各種類型數據(而不僅限於byte型)的格式化表示形式。

PrintStream重載了print和println方法，用於各種不同類型數據的格式化輸出。

格式化輸出是指將一個數據用其字符串格式輸出。

 

DataOutputStream 中的 WriteXXX(data)方法是把data在內存中的二進制數據寫入文件

PrintStream 中的println(data)是該數據格式化后的字符串寫入文件

/*
    DataOutputStream 中的 writeXXX(data)方法
        與
    PrintStream 中的 println(data)的區別
    
    總結:
        DataOutputStream 中的 writeXXX(data)方法是把data在內存中的二進制數據寫入文件
        PrintStream 中的 println(data)寫出的是該數據的格式化后的字符串        
*/

import java.io.*;

public class TestPrintStream_1
{
    public static void main(String[] args) throws Exception 
    {
        DataOutputStream dos = new DataOutputStream(new FileOutputStream("d:/share/kk.txt"));
        dos.writeLong(12345);  //實際寫入文件的是00 00 00 00 00 00 30 39
        dos.close();
        System.out.printf("%#X\n", 12345);
        
        PrintStream ps = new PrintStream(new FileOutputStream("d:/share/kk2.txt"), true);
        ps.println(12345);  //實際寫入文件的是'1' '2' '3' '4' '5'
        ps.close();
    }
}

 

PrintWriter 提供了PrintStream的所有打印方法， 其方法也從不拋出IOException。

與PrintStream的區別：

 

標准輸入輸出的重定向：

實例：編程實現將鍵盤輸入的數據輸入A文件中，如果輸入有誤，則把出錯信息輸出到B文件

import java.io.*;

public class TestSetSystemOut {
    public static void main(String[] args) {
        PrintStream ps_out = null;

        try {
            ps_out = new PrintStream(new FileOutputStream("d:/share/ww.txt"));
            System.setOut(ps_out); // 將System.out的值重新設置為ps_out,即System.out不在關聯到顯示器，而是關聯到"d:/share/ww.txt"文件
            System.out.println(12); // 這實際上是把12輸出到了System.out所關聯的d:/share/ww.txt中
            System.out.println(55.5); // 同上
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                ps_out.close();
            } catch (Exception e) {
                e.printStackTrace();
            }

        }
    }
}

/*
    功能： 將鍵盤輸入的數據輸入A文件中，如果輸入有誤，
           則把出錯信息輸出到B文件中
           
           標准輸入輸出流的重定向    
*/

import java.io.*;
import java.util.*;

public class TestSetOutErr {
    public static void main(String[] args) {
        PrintStream psOut = null;
        PrintStream psError = null;
        Scanner sc = null;

        try {
            psOut = new PrintStream("d:/Out.txt");
            psError = new PrintStream("d:/error.txt");
            sc = new Scanner(System.in);
            int num;
            System.setOut(psOut);
            System.setErr(psError);

            while (true) {
                num = sc.nextInt();
                System.out.println(num);
            }
        } catch (Exception e) {
            System.err.println("出錯的信息是:"); // 不可以寫成System.out.println("出錯的信息是:");
            e.printStackTrace(); // e.printStackTrace(); 默認是輸出到System.err所關聯的設備中
        }
    }
}

 

對象的序列化 ObjectOutputStream ObjectInputStream

所謂序列化是指：把一個Object對象直接轉化為字節流，然后把這個字節流直接寫入本地硬盤或網絡中

序列化流(ObjectOutputStream)----writeObject

反序列化流(ObjectInputStream)---readObject

如果想把某個對象序列化，則必須實現Serializable接口

transient關鍵字用用它修飾變量后該變量不會進行jvm默認的序列化

當我們要把一個對象在網絡上傳輸轉化成字節序列，我們有些變量沒必要使用，放在網絡上傳輸會浪費資源，這個時候我們就會用transient關鍵字

transient修飾的屬性我們可以自己完成序列化

transient關鍵字在有些情況下可以提高性能

實例：

import java.io.*;

public class TestObjectIO
{
    public static void main(String[] args)
    {
        ObjectOutputStream oos = null;
        ObjectInputStream ois = null;
        Student ss = new Student("zhansan", 1000, 88.8f);  //注意88.8f不能改為88.8 
        Student ss2 = null;    
                
        try
        {
            FileOutputStream fos = new FileOutputStream("d:/share/java/ObjectOut.txt");
            oos = new ObjectOutputStream(fos);
            oos.writeObject(ss);
            
            ois = new ObjectInputStream(new FileInputStream("d:/share/java/ObjectOut.txt"));    
            ss2 = (Student)ois.readObject();  //(Student)不能省   ois.readObject();如果ois中的某個成員是transient,則該成員是不會被讀取的，因為該成員不會被保存，何來讀取之說？！
            
            System.out.println("ss2.sname = " + ss2.sname);
            System.out.println("ss2.sid = " + ss2.sid);
            System.out.println("ss2.sscore = " + ss2.sscore);
        }
        catch (FileNotFoundException e)
        {
            System.out.println("文件沒有找到!");
            System.exit(-1);
        }
        catch (Exception e)
        {
            e.printStackTrace();
            System.exit(-1);
        }
        finally
        {
            try
            {
                oos.close();
                ois.close();
            }
            catch (Exception e)
            {
                e.printStackTrace();
                System.exit(-1);
            }
        }        
    }
}

class Student implements Serializable  //如果將implements Serializable 注釋掉，則程序編譯時就會報錯
{
    public String sname = null;
    public int sid = 0;
    transient public float sscore = 0; //表示sscore成員不能被序列化，所謂不能被序列化就是指：“該成員調用ObjectOutputStream 的writeOnbject()時不會被保存，調用ObjectInputStream的readObject()方法時不會被讀取”
    
    public Student(String name, int id, float score)
    {
        this.sname = name;
        this.sid = id;
        this.sscore =  score;
    }
}

 

分析ArrayList源碼中序列化和反序列化的問題

ArrayList的底層雖然是一個數組，但是這個數組不一定放滿，沒有放滿的數組元素是不需要進行序列化的，我們必須自己完成序列化，把有效元素一個一個自己完成序列化 ，反序列化也一樣，所以ArrayList源碼中的序列化和反序列化的作用就是把ArrayList中的有效元素進行序列化 無效元素不進行序列化，可以提高性能。

對ArrayList的源碼有個初步的了解，能夠進行序列化的優化問題

 

序列化中 子類和父類構造函數的調用問題

當一個子類的父類實現了序列化接口，子類可以直接進行序列化 ，子類序列化時會遞歸調用父類的構造方法。

對子類對象進行反序列化操作時，如果其父類沒有實現序列化接口，那么其父類的構造方法會被調用