12Java進階-IO與XML

1.File

File：java.io.File:代表一個實際的檔案或目錄，

常用構造方法File file = new File("path");

其它構造方法：

• File(String parent, String child)：創建一個新的 File 實體，該實體的存放路徑是由 parent 和 child 拼接而成的，
• File(File parent, String child)：創建一個新的 File 實體， parent 代表目錄， child 代表檔案名，因此該實體的存放路徑是 parent 目錄中的 child 檔案，
• File(URI uri)：創建一個新的 File 實體，該實體的存放路徑是由 URI 型別的引數指定的，

構造File時，路徑需要符合作業系統的命名規則，

路徑分隔符File.pathSeperator:在windows中是“;”，在Linux中是":"

路徑分隔符File.pathSeperatorChar:在windows中是’;‘，在Linux中是':'

層次路徑分隔符File.seperator:在windows中是"\",在Linux中是"/"

層次路徑分隔符File.seperatorChar:在windows中是’\‘,在Linux中是’/’

File常用方法：

File.listRoots()：列出根目錄

file.exists()：檔案是否存在

fie.isDirectory():檔案是否是目錄

String[] list()：回傳一個字串陣列，這些字串代表此抽象路徑名表示的目錄中的檔案和目錄，
String[] list(FilenameFilter filter)：回傳一個字串陣列，這些字串代表此抽象路徑名表示的目錄中，滿足過濾器 filter 要求的檔案和目錄，
File[] listFiles()：回傳一個 File 物件陣列，表示此當前 File 物件中的檔案和目錄，
File[] listFiles(FilenameFilter filter)：回傳一個 File 物件陣列，表示當前 File 物件中滿足過濾器 filter 要求的檔案和目錄，

2.IO流

抽象輸入位元組流介面：InputStream 抽象輸出位元組流介面：OutputStream

常見的輸入流：new Scanner(System.in) 常見的輸出流：System.out.print();

按照傳輸的單位分為：位元組流和字符流，

位元組流通常用來處理二進制檔案，如音樂、圖片檔案等，并且由于位元組是任何資料都支持的資料型別，因此位元組流實際可以處理任意型別的資料，而對于字符流，因為 Java 采用 Unicode 編碼，Java 字符流處理的即 Unicode 字符，所以在操作文字、國際化等方面，字符流具有優勢，

• FileInputStream：把一個檔案作為輸入源，從本地檔案系統中讀取資料位元組，實作對檔案的讀取操作，
• ByteArrayInputStream：把記憶體中的一個緩沖區作為輸入源，從記憶體陣列中讀取資料位元組，
• ObjectInputStream：對以前使用 ObjectOutputStream 寫入的基本資料和物件進行反序列化，用于恢復那些以前序列化的物件，注意這個物件所屬的類必須實作 Serializable 介面，
• PipedInputStream：實作了管道的概念，從執行緒管道中讀取資料位元組，主要在執行緒中使用，用于兩個執行緒間的通信，
• SequenceInputStream：其他輸入流的邏輯串聯，它從輸入流的有序集合開始，并從第一個輸入流開始讀取，直至到達檔案末尾，接著從第二個輸入流讀取，依次類推，
• System.in：從用戶控制臺讀取資料位元組，在 System 類中，in 是 InputStream 型別的靜態成員變數，

InputStream常見方法：

int read()：從輸入流中讀取資料的下一位元組，回傳 0 ～ 255 范圍內的整型位元組值；如果輸入流中已無新的資料，則回傳 -1，
int read(byte[] b)：從輸入流中讀取一定數量的位元組，并將其存盤在位元組陣列 b 中，以整數形式回傳實際讀取的位元組數（要么是位元組陣列的長度，要么小于位元組陣列的長度），
int read(byte[] b, int off, int len)：將輸入流中最多 len 個資料位元組讀入位元組陣列 b 中，以整數形式回傳實際讀取的位元組數，off 指陣列 b 中將寫入資料的初始偏移量，
void close()：關閉此輸入流，并釋放與該流關聯的所有系統資源，
int available()：回傳可以不受阻塞地從此輸入流讀取（或跳過）的估計位元組數，
void mark(int readlimit)：在此輸入流中標記當前的位置，
void reset()：將此輸入流重新定位到上次 mark 的位置，
boolean markSupported()：判斷此輸入流是否支持 mark() 和 reset() 方法，
long skip(long n)：跳過并丟棄此輸入流中資料的 n 位元組，

字符的輸入輸出流：

抽象字符輸入流：Reader 抽象字符輸出流：Writer

• FileReader ：與 FileInputStream 對應，從檔案系統中讀取字符序列，
• CharArrayReader ：與 ByteArrayInputStream 對應，從字符陣列中讀取資料，
• PipedReader ：與 PipedInputStream 對應，從執行緒管道中讀取字符序列，
• StringReader ：從字串中讀取字符序列，

字符輸出流的常用方法：

Writer append(char c)：將指定字符 c 追加到此 Writer，此處是追加，不是覆寫，
Writer append(CharSequence csq)：將指定字符序列 csq 添加到此 Writer，
Writer append(CharSequence csq, int start, int end)：將指定字符序列 csq 的子序列，追加到此 Writer，
void write(char[] cbuf)：寫入字符陣列 cbuf，
void write (char[] cbuf, int off, int len)：寫入字符陣列 cbuf 的某一部分，
void write(int c)：寫入單個字符 c，
void write(String str)：寫入字串 str，
void write(String str, int off, int len)：寫入字串 str 的某一部分，
void close()：關閉當前流，

位元組流、字符流都是無緩沖的輸入、輸出流，每次的讀、寫操作都會交給作業系統來處理，對系統的性能造成很大的影響，因為每次操作都可能引發磁盤硬體的讀、寫或網路的訪問，這些磁盤硬體讀、寫和網路訪問會占用大量系統資源，影響效率，

3.裝飾器模式

通過方法，將物件進行包裝，

比如FileOutputStream放在緩沖位元組流BufferedOutputStream的構造方法中時，就變成了BufferedOutputStream， 

再把BufferedOutputStream放在DataOutputStream的構造方法中，就變成了DataOutputStream，

雖然外觀都是OutputStream，但是功能得到了增強，提供了更加豐富的API，

4.Buffered流

緩沖流的目的是讓原位元組流、字符流新增緩沖的功能，

• BufferedInputStream
• BufferedOutputStream
• BufferedReader
• BufferedWriter

5.位元組流轉換為字符流：

使用InputStreamReader將位元組流轉換成InputStreamReader物件，再通過字符流的建構式轉換成字符流，

Java沒有提供位元組流轉換成字符流的方式，因為位元組流是一個通用的流，而字符流只能傳輸文本型別的資源，但是傳輸效率較快，

6.Data流

DataStream允許流直接操作基本資料型別和字串，常用的方法有

dos.writeUTF(); 

dos.writeInt(); 

dis.readUTF();

dis.readInt();

注意讀取順序要和寫入順序一致，

    public static void main(String[] args) {
        try {
            DataOutputStream dos = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(new File("D:\\ideaproject\\Java02\\data.txt"))));
            dos.writeUTF("this");
            dos.writeUTF("is");
            dos.writeInt(4);
            dos.writeUTF("leellamarz");
            dos.close();
            DataInputStream dis  = new DataInputStream(new BufferedInputStream(new FileInputStream(new File("D:\\ideaproject\\Java02\\data.txt"))));
            String a = dis.readUTF();
            String b = dis.readUTF();
            int d = dis.readInt();
            String c = dis.readUTF();
            System.out.println(a+" "+b+" "+d+" "+c);
            dis.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

7.XML

XML是可拓展標記語言，可以用來存盤資料、系統配置、資料交換，

XML的標簽可以自定義，

XML 檔案總是以 XML 宣告開始，即告知處理程式，本檔案是一個 XML 檔案，在 XML 宣告中，通常包括版本、編碼等資訊，以 <? 開始，以 ?> 結尾，

<?xml version = "1.0" encoding="UTF-8"?>

XML 檔案由元素組成，一個元素由一對標簽來定義，包括開始和結束標簽，以及其中的內容，元素之間可以嵌套（但不能交叉），也就是說元素的內容里還可以包含元素，

標簽可以有屬性（屬性值要加引號），屬性是對標簽的進一步描述和說明，一個標簽可以有多個屬性，每個屬性都有自己的名字和值，屬性是標簽的一部分，

8.決議XML

決議XML的技術主要有：

• DOM 即org.w3c.dom，W3C 推薦的用于使用 DOM 決議 XML 檔案的介面
• SAX 即org.xml.sax，用 SAX 決議 XML 檔案的介面

DOM 把一個 XML 檔案映射成一個分層物件模型，而這個層次的結構，是一棵根據 XML 檔案生成的節點樹，DOM 在對 XML 檔案進行分析之后，不管這個檔案有多簡單或多復雜，其中的資訊都會被轉化成一棵物件節點樹，在這棵節點樹中，有一個根節點，其他所有的節點都是根節點的子節點，節點樹生成之后，就可以通過 DOM 介面訪問、修改、添加、洗掉樹中的節點或內容了，

DOM決議程序：

1. 通過getInstance()創建DocumentBuilderFactory，即決議器工廠
2. 通過build()創建DocumentBuilder
3. 決議檔案得到Document物件
4. 通過NodeList，開始決議結點（標簽）

9.Node常用方法

NodeList getChildNodes()：回傳此節點的所有子節點的 NodeList，
Node getFirstChild()：回傳此節點的第一個子節點，
Node getLastChild()：回傳此節點的最后一個子節點，
Node getNextSibling()：回傳此節點之后的節點，
Node getPreviousSibling()：回傳此節點之前的節點，
Document getOwnerDocument()：回傳與此節點相關的 Document 物件，
Node getParentNode()：回傳此節點的父節點，
short getNodeType()：回傳此節點的型別，
String getNodeName()：根據此節點型別，回傳節點名稱，
String getNodeValue()：根據此節點型別，回傳節點值，

String getTextContent()：回傳此節點的文本內容，
void setNodeValue(String nodeValue)：根據此節點型別，設定節點值，
void setTextContent(String textContent)：設定此節點的文本內容，
Node appendChild(Node newChild)：將節點 newChild 添加到此節點的子節點串列的末尾，
Node insertBefore(Node newChild,Node refChild)：在現有子節點 refChild 之前插入節點 newChild，
Node removeChild(Node oldChild)：從子節點串列中移除 oldChild 所指示的子節點，并將其回傳，
Node replaceChild(Node newChild, oldChild)：將子節點串列中的子節點 oldChild 替換為 newChild，并回傳 oldChild 節點，

10.Document常用方法

Element getDocumentElement()：回傳代表這個 DOM 樹根節點的 Element 物件，
NodeList getElementsByTagName(String tagname)：按檔案順序回傳包含在檔案中且具有給定標記名稱的所有 Element 的 NodeList，

NodeList常用方法：

int getLength()：回傳有序集合中的節點數，
Node item(int index)：回傳有序集合中的第 index 個項，

11.SAX決議

SAX是事件驅動的，通過繼承DefaultHandler類，重寫五個關鍵方法實作決議，

startDocument():開始檔案的標志

endDocument():結束檔案的標志

startElement(String uri, String localName, String qName, Attributes attributes)：通過比較localName，找到指定的元素，打開元素

endElement(String uri, String localName, String qName):通過比較localName，找到指定的元素，結束元素

characters(char[] ch, int start, int length)：決議每個元素時呼叫的方法

@Override
    public void startDocument() throws SAXException {
        System.out.println("books2檔案開始決議");
    }

    @Override
    public void endDocument() throws SAXException {
        System.out.println("books2檔案結束決議");
    }

    @Override
    public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
        if (qName.equals("book")) {
           for(int i=0;i<attributes.getLength();i++){
               System.out.println("編號："+attributes.getValue(i));
           }

        }
        this.tagName = qName;
    }

    @Override
    public void endElement(String uri, String localName, String qName) throws SAXException {
        if("book".equals(localName)){}
        this.tagName = null;
    }

    @Override
    public void characters(char[] ch, int start, int length) throws SAXException {
        if (this.tagName != null) {
            String data = new String(ch, start, length);
            if (this.tagName.equals("bookname")) {
                System.out.println("書名："+data);
            }
            if (this.tagName.equals("bookauthor")) {
                System.out.println("作者："+data);
            }

            if (this.tagName.equals("bookprice")) {
                System.out.println("價格："+data);
            }


        }
    }

12.練習

 如果子類例外塊放在父類例外塊后面，就會報編譯錯誤，

  try {
            int[] a = {1,2,3};
            System.out.print(a[3]);
            System.out.print(1);
        } catch(Exception e) {
            System.out.print(2);
            System.exit(0);//2
        } finally {
            System.out.print(3);
        }

不同于return，System.exit(0)的優先級高于finally，在前面遇到會直接退出程式，

 例外向外拋出，再被外部trycatch接受，會造成死回圈

ArrayList<String> a = new ArrayList<String>();
a.add(true);
a.add(123);
a.add("abc");
System.out.print(a);
//執行后，控制臺輸出為？編譯錯誤
//集合定義時加了泛型后，就不能添加不匹配泛型的元素，

List a = new ArrayList();
a.add(1);
a.add(2);
a.add(3);
a.remove(1);
System.out.print(a);
//執行后，控制臺輸出為？ 1 3
//ArrayList 有 2 個洗掉方法：a.remove(Object o); 和 a.remove(int index); 那么這里的 1 到底是匹配 Object 還是 int 型別呢？我們考慮一下這兩個方法的來歷就行了，
//a.remove(Object o); 是父介面的方法，a.remove(int index); 是子類重寫的方法，所以這里應該是呼叫子類重寫的方法，

Set ts = new TreeSet();
ts.add("zs");
ts.add("ls");
ts.add("ww");
System.out.print(ts);
//執行后，控制臺輸出為？
//TreeSet 對于字串來說默認按照字典升序進行排序，所以答案為：[ls, ww, zs]

//假設檔案 c:/a.txt 的內容為 abc
//以下代碼
try {
    File f = new File("c:/a.txt");
    System.out.print(f.length());
    OutputStream out = new FileOutputStream(f);
    System.out.print(f.length());
    out.write(97);
    System.out.print(f.length());
    out.close();
} catch (FileNotFoundException e) {
    e.printStackTrace();
} catch (IOException e) {
    e.printStackTrace();
}
//執行后，控制臺輸出為？301

File 物件 new 出來后，f.length() 回傳值為 3，

FileOutputStream 物件 new 出來后，由于默認方法是覆寫已經存在的檔案，所以f.length() 回傳值為 0，如果想不覆寫，應該使用new FileOutputStream(f,false);，

out.write(97) 寫入字母 a 后，f.lenght() 回傳值為 1，

if(node2 instanceof Element){
String string = node2.getNodeName();
String ste = node2.getTextContent();
System.out.println(string+" "+ste);
}

出現這種問題的原因主要是使用org.w3c.dom.Node的進行決議的，它會將你的回車也作為一個節點，在你的代碼中你列印str.getLenth();得到的數值肯定比你寫的節點要多，
如果：node2 instanceof Text，則輸出：#text
如果：node2 instanceof Element，則輸出：標簽名

或者將檔案中多余的空格和回車都去掉，

標籤：其他

上一篇：9Java基礎總結

下一篇：決議ArrayList的底層實作（上）