byterat

　　一、多樣化摺疊菜單：下載

　　一個由老外寫的折疊式垂直菜單，多樣化，多功能，可自訂，使用容易，支持FF。

圖1

　　二、CSS圓角邊框：下載

　　以CSS為主要，用Java Script封裝的相當完整，也是老外寫的，支持多瀏覽器，可以自訂樣式，目前有十多種可以運用。

圖2

圖3

　　三、模擬視窗：下載

　　用層模擬的視窗，是一個中國高手寫的，Java Script封裝的相當好，使用上也很容易

圖4

　　四、支持FF的省略符：下載

　　說到省略符，那非CSS莫屬，有個老外用Java Script來實現，并且是批量處理的，重點是支持FF。

圖5

　　五、TAB選項卡：下載

　　用Java Script模仿各種作業系統的選項卡，老外就是牛，不僅支援多樣式的即時切換，同時也支援每個選項卡是否附帶圖示的切換選項，選項卡也可以上下切換。

圖6

　　六、最佳化多樣式Windows：下載

　　用層模擬視窗的最佳代表作，這是我看過功能最多的模擬式窗，內附多達74項功能與樣式，你完完全全可以把它當成是一個真正的視窗來應用，可以根據你的需求來應用，快丟掉你那認為好用的層視窗，這套封裝非常完整的視窗絕對可以滿足你的各種需求。

圖7

圖8

　　七、多樣化的垂直菜單：附件

　　別具風格的方塊式垂直折疊菜單，目前有8種風格可以運用，如果你已經厭煩WEB上平凡的菜單，這套在國外頗受歡迎的菜單肯定是你的最佳首選。

圖9

　　八、多樣化的連結提示效果：下載

　　這個連結提示樣式允許你直接寫入css與html，共有14項功能可以讓你自訂。

圖10

　　九、側欄式折疊菜單：下載

　　這是一個側欄式的折疊菜單，它允許你設置它是否有過渡效果、側欄菜單是否自動伸縮、菜單項切換是否允許動畫過渡、是否輪替切換等多項設置，并且也有多種樣式可以運用。

　　這個腳本有個很好玩的東東，下載并且解壓後，請進入samples的目錄并打show.html看看效果，我不知道這效果容不容易實現，但是這效果很牛，菜單全自動運行的～

圖11

　　十、圖形滾動條：下載

　　老外寫的圖形滾動條，有多種樣式，在ie里頭還支持滾輪滾動。

圖12

　　十一、圖片倒影效果：下載
　　說到圖片倒影，不外乎就是直接作成圖片跟css濾鏡來實現，但是這個是用Java Script實現的，值得借鏡。

圖13

　　十二、代碼自動高亮：下載

　　雖說這不是什麼新東西，但總是會有人需要吧，而且想學正則表達的人，這肯定是最佳借鏡的作品。

圖14

BIG-ENDIAN（大字節序、高字節序）
LITTLE-ENDIAN（小字節序、低字節序）
主機字節序
網絡字節順序
JAVA字節序

1．BIG-ENDIAN、LITTLE-ENDIAN跟多字節類型的數據有關的比如int,short,long型，而對單字節數據byte卻沒有影響。BIG-ENDIAN就是低位字節排放在內存的低端，高位字節排放在內存的高端。而LITTLE-ENDIAN正好相反。
比如 int a = 0x05060708
在BIG-ENDIAN的情況下存放為：
字節號 0 1 2 3
數據 05 06 07 08
在LITTLE-ENDIAN的情況下存放為：
字節號 0 1 2 3
數據 08 07 06 05

2．BIG-ENDIAN、LITTLE-ENDIAN、跟CPU有關的，每一種CPU不是BIG-ENDIAN就是LITTLE-ENDIAN、。IA架構的CPU中是Little-Endian，而PowerPC 、SPARC和Motorola處理器。這其實就是所謂的主機字節序。而網絡字節序是指數據在網絡上傳輸時是大頭還是小頭的，在Internet的網絡字節序是BIG-ENDIAN。所謂的JAVA字節序指的是在JAVA虛擬機中多字節類型數據的存放順序，JAVA字節序也是BIG-ENDIAN。

3．所以在用C/C++寫通信程序時，在發送數據前務必用htonl和htons去把整型和短整型的數據進行從主機字節序到網絡字節序的轉換，而接收數據后對于整型和短整型數據則必須調用ntohl和ntohs實現從網絡字節序到主機字節序的轉換。如果通信的一方是JAVA程序、一方是C/C++程序時，則需要在C/C++一側使用以上幾個方法進行字節序的轉換，而JAVA一側，則不需要做任何處理，因為JAVA字節序與網絡字節序都是BIG-ENDIAN，只要C/C++一側能正確進行轉換即可（發送前從主機序到網絡序，接收時反變換）。如果通信的雙方都是JAVA，則根本不用考慮字節序的問題了。

4．如果網絡上全部是PowerPC,SPARC和Motorola CPU的主機那么不會出現任何問題，但由于實際存在大量的IA架構的CPU，所以經常出現數據傳輸錯誤。

5．文章開頭所提出的問題，就是因為程序運行在X86架構的PC SERVER上，發送數據的一端用C實現的，接收一端是用JAVA實現的，而發送端在發送數據前未進行從主機字節序到網絡字節序的轉換，這樣接收端接收到的是LITTLE-ENDIAN的數據，數據解釋自然出錯。
具體數據如下，實際發送的數據為23578
發送端發送數據： 1A 5C
接收端接收到數據后，按BIG-ENDIAN進行解釋具體數據是多少？你們自己去計算并比較吧！


===============================================================================================

Big Endian and Little Endian

    談到字節序的問題，必然牽涉到兩大CPU派系。那就是Motorola的PowerPC系列CPU和Intel的x86系列CPU。PowerPC系列采用big endian方式存儲數據，而x86系列則采用little endian方式存儲數據。那么究竟什么是big endian，什么又是little endian呢？

    其實big endian是指低地址存放最高有效字節（MSB），而little endian則是低地址存放最低有效字節（LSB），即常說的低位在先，高位在后。
    用文字說明可能比較抽象，下面用圖像加以說明。比如數字0x12345678在兩種不同字節序CPU中的存儲順序如下所示：

Big Endian

  低地址                           高地址
  ----------------------------------------->
  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  |     12     |      34    |     56      |     78    |
  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

Little Endian

  低地址                           高地址
  ----------------------------------------->
  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  |     78     |      56    |     34      |     12    |
  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

    從上面兩圖可以看出，采用big endian方式存儲數據是符合我們人類的思維習慣的。而little endian，!@#$%^&*，見鬼去吧 -_-|||

    為什么要注意字節序的問題呢？你可能這么問。當然，如果你寫的程序只在單機環境下面運行，并且不和別人的程序打交道，那么你完全可以忽略字節序的存在。但是，如果你的程序要跟別人的程序產生交互呢？尤其是當你把你在微機上運算的結果運用到計算機群上去的話。在這里我想說說兩種語言。C/C++語言編寫的程序里數據存儲順序是跟編譯平臺所在的CPU相關的，而JAVA編寫的程序則唯一采用big endian方式來存儲數據。試想，如果你用C/C++語言在x86平臺下編寫的程序跟別人的JAVA程序互通時會產生什么結果？就拿上面的 0x12345678來說，你的程序傳遞給別人的一個數據，將指向0x12345678的指針傳給了JAVA程序，由于JAVA采取big endian方式存儲數據，很自然的它會將你的數據翻譯為0x78563412。什么？竟然變成另外一個數字了？是的，就是這種后果。因此，在你的C程序傳給JAVA程序之前有必要進行字節序的轉換工作。

    無獨有偶，所有網絡協議也都是采用big endian的方式來傳輸數據的。所以有時我們也會把big endian方式稱之為網絡字節序。當兩臺采用不同字節序的主機通信時，在發送數據之前都必須經過字節序的轉換成為網絡字節序后再進行傳輸。ANSI C中提供了四個轉換字節序的宏。

========================================================================================================

/**
* 通信格式轉換
*
* Java和一些windows編程語言如c、c++、delphi所寫的網絡程序進行通訊時，需要進行相應的轉換
* 高、低字節之間的轉換
* windows的字節序為低字節開頭
* linux,unix的字節序為高字節開頭
* java則無論平臺變化，都是高字節開頭
*/

public class FormatTransfer {
/**
  * 將int轉為低字節在前，高字節在后的byte數組
  * @param n int
  * @return byte[]
  */
public static byte[] toLH(int n) {
  byte[] b = new byte[4];
  b[0] = (byte) (n & 0xff);
  b[1] = (byte) (n >> 8 & 0xff);
  b[2] = (byte) (n >> 16 & 0xff);
  b[3] = (byte) (n >> 24 & 0xff);
  return b;
}

/**
  * 將int轉為高字節在前，低字節在后的byte數組
  * @param n int
  * @return byte[]
  */
public static byte[] toHH(int n) {
  byte[] b = new byte[4];
  b[3] = (byte) (n & 0xff);
  b[2] = (byte) (n >> 8 & 0xff);
  b[1] = (byte) (n >> 16 & 0xff);
  b[0] = (byte) (n >> 24 & 0xff);
  return b;
}

/**
  * 將short轉為低字節在前，高字節在后的byte數組
  * @param n short
  * @return byte[]
  */
public static byte[] toLH(short n) {
  byte[] b = new byte[2];
  b[0] = (byte) (n & 0xff);
  b[1] = (byte) (n >> 8 & 0xff);
  return b;
}

/**
  * 將short轉為高字節在前，低字節在后的byte數組
  * @param n short
  * @return byte[]
  */
public static byte[] toHH(short n) {
  byte[] b = new byte[2];
  b[1] = (byte) (n & 0xff);
  b[0] = (byte) (n >> 8 & 0xff);
  return b;
}

/**
  * 將將int轉為高字節在前，低字節在后的byte數組

public static byte[] toHH(int number) {
  int temp = number;
  byte[] b = new byte[4];
  for (int i = b.length - 1; i > -1; i--) {
    b = new Integer(temp & 0xff).byteValue();
    temp = temp >> 8;
  }
  return b;
}

public static byte[] IntToByteArray(int i) {
    byte[] abyte0 = new byte[4];
    abyte0[3] = (byte) (0xff & i);
    abyte0[2] = (byte) ((0xff00 & i) >> 8);
    abyte0[1] = (byte) ((0xff0000 & i) >> 16);
    abyte0[0] = (byte) ((0xff000000 & i) >> 24);
    return abyte0;
}

*/

/**
  * 將float轉為低字節在前，高字節在后的byte數組
  */
public static byte[] toLH(float f) {
  return toLH(Float.floatToRawIntBits(f));
}

/**
  * 將float轉為高字節在前，低字節在后的byte數組
  */
public static byte[] toHH(float f) {
  return toHH(Float.floatToRawIntBits(f));
}

/**
  * 將String轉為byte數組
  */
public static byte[] stringToBytes(String s, int length) {
  while (s.getBytes().length < length) {
    s += " ";
  }
  return s.getBytes();
}

/**
  * 將字節數組轉換為String
  * @param b byte[]
  * @return String
  */
public static String bytesToString(byte[] b) {
  StringBuffer result = new StringBuffer("");
  int length = b.length;
  for (int i=0; i<length; i++) {
    result.append((char)(b & 0xff));
  }
  return result.toString();
}

/**
  * 將字符串轉換為byte數組
  * @param s String
  * @return byte[]
  */
public static byte[] stringToBytes(String s) {
  return s.getBytes();
}

/**
  * 將高字節數組轉換為int
  * @param b byte[]
  * @return int
  */
public static int hBytesToInt(byte[] b) {
  int s = 0;
  for (int i = 0; i < 3; i++) {
    if (b >= 0) {
    s = s + b;
    } else {
    s = s + 256 + b;
    }
    s = s * 256;
  }
  if (b[3] >= 0) {
    s = s + b[3];
  } else {
    s = s + 256 + b[3];
  }
  return s;
}

/**
  * 將低字節數組轉換為int
  * @param b byte[]
  * @return int
  */
public static int lBytesToInt(byte[] b) {
  int s = 0;
  for (int i = 0; i < 3; i++) {
    if (b[3-i] >= 0) {
    s = s + b[3-i];
    } else {
    s = s + 256 + b[3-i];
    }
    s = s * 256;
  }
  if (b[0] >= 0) {
    s = s + b[0];
  } else {
    s = s + 256 + b[0];
  }
  return s;
}

/**
  * 高字節數組到short的轉換
  * @param b byte[]
  * @return short
  */
public static short hBytesToShort(byte[] b) {
  int s = 0;
  if (b[0] >= 0) {
    s = s + b[0];
    } else {
    s = s + 256 + b[0];
    }
    s = s * 256;
  if (b[1] >= 0) {
    s = s + b[1];
  } else {
    s = s + 256 + b[1];
  }
  short result = (short)s;
  return result;
}

/**
  * 低字節數組到short的轉換
  * @param b byte[]
  * @return short
  */
public static short lBytesToShort(byte[] b) {
  int s = 0;
  if (b[1] >= 0) {
    s = s + b[1];
    } else {
    s = s + 256 + b[1];
    }
    s = s * 256;
  if (b[0] >= 0) {
    s = s + b[0];
  } else {
    s = s + 256 + b[0];
  }
  short result = (short)s;
  return result;
}

/**
  * 高字節數組轉換為float
  * @param b byte[]
  * @return float
  */
public static float hBytesToFloat(byte[] b) {
  int i = 0;
  Float F = new Float(0.0);
  i = ((((b[0]&0xff)<<8 | (b[1]&0xff))<<8) | (b[2]&0xff))<<8 | (b[3]&0xff);
  return F.intBitsToFloat(i);
}

/**
  * 低字節數組轉換為float
  * @param b byte[]
  * @return float
  */
public static float lBytesToFloat(byte[] b) {
  int i = 0;
  Float F = new Float(0.0);
  i = ((((b[3]&0xff)<<8 | (b[2]&0xff))<<8) | (b[1]&0xff))<<8 | (b[0]&0xff);
  return F.intBitsToFloat(i);
}

/**
  * 將byte數組中的元素倒序排列
  */
public static byte[] bytesReverseOrder(byte[] b) {
  int length = b.length;
  byte[] result = new byte[length];
  for(int i=0; i<length; i++) {
    result[length-i-1] = b;
  }
  return result;
}

/**
  * 打印byte數組
  */
public static void printBytes(byte[] bb) {
  int length = bb.length;
  for (int i=0; i<length; i++) {
    System.out.print(bb + " ");
  }
  System.out.println("");
}

public static void logBytes(byte[] bb) {
  int length = bb.length;
  String ut = "";
  for (int i=0; i<length; i++) {
    ut = out + bb + " ";
  }

}

/**
  * 將int類型的值轉換為字節序顛倒過來對應的int值
  * @param i int
  * @return int
  */
public static int reverseInt(int i) {
  int result = FormatTransfer.hBytesToInt(FormatTransfer.toLH(i));
  return result;
}

/**
  * 將short類型的值轉換為字節序顛倒過來對應的short值
  * @param s short
  * @return short
  */
public static short reverseShort(short s) {
  short result = FormatTransfer.hBytesToShort(FormatTransfer.toLH(s));
  return result;
}

/**
  * 將float類型的值轉換為字節序顛倒過來對應的float值
  * @param f float
  * @return float
  */
public static float reverseFloat(float f) {
  float result = FormatTransfer.hBytesToFloat(FormatTransfer.toLH(f));
  return result;
}

}

緩沖區基礎

抽象類Buffer是java.nio包支持緩沖區的基礎。 Buffer 的工作方式就象內存中用于讀寫基本數據類型的 RandomAccessFile 。象 RandomAccessFile 一樣，使用 Buffer ，所執行的下一個操作（讀／寫）在當前某個位置發生。執行讀／寫操作中的任一個都會改變那個位置，所以在寫操作之后進行讀操作不會讀到剛才所寫的內容，而會讀到剛才所寫內容之后的數據。 Buffer 提供了四個指示方法，用于訪問線性結構（從最高值到最低值）：

capacity() ：表明緩沖區的容量大小, 一旦確定了大小, 將不能再改變;
limit() ：告訴您到目前為止已經往緩沖區填了多少字節，或者讓您用 :limit(int newLimit) 來改變這個限制
position() ：告訴您當前的位置，以執行下一個讀／寫操作
mark() ：為了稍后用 reset() 進行重新設置而記住某個位置
flip() ：交換限制指針和位置指針，然后將位置置為 0，并廢棄已經做的mark標記

緩沖區的基本操作是讀 get() 和寫 put() ；然而，這些方法在子類中都是針對每種數據類型的特定方法。為了說明這一情況，讓我們研究一個簡單示例，該示例演示了從同一個緩沖區讀和寫一個字符。在清單 1 中， flip() 方法交換限制和位置，然后將位置置為 0，并廢棄標記，讓您讀剛才所寫的數據：

清單 1. 讀／寫示例
import java.nio.*;
...
CharBuffer buff = ...;
buff.put('A');
buff.flip();
char c = buff.get();
System.out.println("An A: " + c);
 

現在讓我們研究一些具體的 Buffer 子類。

緩沖區類型

Merlin 具有 7 種特定的 Buffer 類型，每種類型對應著一個基本數據類型（不包括 boolean）：

ByteBuffer       //存放任何除boolean類型外的其他基本類型
CharBuffer       //存放char
DoubleBuffer     //存放double
FloatBuffer      //存放float
IntBuffer        //存放int
LongBuffer       //存放long
ShortBuffer      //存放short

在本文后面，我將討論第 8 種類型 MappedByteBuffer ，它用于內存映射文件。如果您必須使用的類型不是這些基本類型，則可以先從 ByteBuffer 獲得字節類型，然后將其轉換成 Object 或其它任何類型。


創建緩沖區
一共有兩種類型的緩沖區，直接緩沖區和非直接緩沖區。

在創建緩沖區時，可以要求創建直接緩沖區，創建直接緩沖區的成本要比創建間接緩沖區高，但這可以使運行時環境直接在該緩沖區上進行較快的本機 I/O 操作。因為創建直接緩沖區所增加的成本，所以直接緩沖區只用于長生存期的緩沖區，而不用于短生存期、一次性且用完就丟棄的緩沖區。而且，只能在 ByteBuffer 這個級別上創建直接緩沖區，如果希望使用其它類型，則必須將 Buffer 轉換成更具體的類型。

判斷一個緩沖區是否是直接緩沖區，可以調用isDirect()方法。

有三種方式來獲取一個緩沖區的對象：
a. 調用allocate()或者allocateDirect()方法直接分配，其中allocateDirect()返回的是直接緩沖區。
b. 包裝一個數組，如：
      byte[] b = new byte[1024];
      ByteBuffer bb = ByteBuffer.wrap(b);
c. 內存映射，即調用FileChannel的map()方法。

緩沖區基本屬性
這幾個屬性是每個緩沖區都有的并且是常用的操作。
a. 容量(capacity),緩沖區大小
b. 限制(limit),第一個不應被讀取或寫入的字節的索引，總是小于容量。
c. 位置(position)，下一個被讀取或寫入的字節的索引，總是小于限制。
d. clear()方法：設置limit為capacity，position為0。
e. filp()方法：設置limit為當前position，然后設置position為0。
f. rewind()方法：保持limit不變，設置position為0。

緩沖區數據操作
操作包括了讀取和寫入數據兩種。
讀取數據使用get()及其系列方法，除boolean外，每一種類型包括了對應的get()方法，如getInt(),getChar()等，get()方法用來讀取字節，支持相對和絕對索引兩種方式。
寫入數據使用put()及其系列方法，和get()方法是對應的。

package nio;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public class BufferDemo ...{

    
    public static void main(String[] args) throws Exception...{
        //分配一個非直接緩沖區
        ByteBuffer bb = ByteBuffer.allocate(100);
        //向緩沖區寫入0到100的字節制
        for(int i = 0; i <100; i++)...{
            byte b = (byte) (Math.random() * 100);
            bb.put(b);
        }
        
        System.out.println("寫入文件前的緩沖區數據");
        bb.flip();
        while(bb.hasRemaining())
            System.out.print(bb.get() + " ");
        System.out.println();
        
        //獲取一個關聯到文件buffer.txt的信道
        FileChannel fc = new FileOutputStream("buffer.txt").getChannel();
        //將緩沖區數據寫到文件中
        bb.flip();
        fc.write(bb);
        //防止緩存
        fc.force(true);
        //關閉信道
        fc.close();
        bb = null;
        fc = null;
        
        //下面從文件中讀取數據
        fc = new FileInputStream("buffer.txt").getChannel();
        ByteBuffer bb2 = ByteBuffer.allocate((int) fc.size());
        fc.read(bb2);
        System.out.println("從文件讀取的緩沖區數據");
        bb2.flip();
        while(bb2.hasRemaining())
            System.out.print(bb2.get() + " ");
        System.out.println();
        fc.close();
        bb2 = null;
        fc = null;
        

    }

}

內存映射文件

第 8 種 Buffer 類型 MappedByteBuffer 只是一種特殊的 ByteBuffer 。 MappedByteBuffer 將文件所在區域直接映射到內存。通常，該區域包含整個文件，但也可以只映射部分文件。所以，必須指定要映射文件的哪部分。而且，與其它 Buffer 對象一樣，這里沒有構造函數；必須讓 java.nio.channels.FileChannel 的 map() 方法來獲取 MappedByteBuffer 。此外，無需過多涉及通道就可以用 getChannel() 方法從 FileInputStream 或 FileOutputStream 獲取 FileChannel 。通過從命令行傳入文件名來讀取文本文件的內容，清單 4 顯示了 MappedByteBuffer ：

清單 4. 讀取內存映射文本文件
import java.io.*;
import java.nio.*;
import java.nio.channels.*;
import java.nio.charset.*;
public class ReadFileBuff {
  public static void main(String args[]) throws IOException {
     if (args.length != 0) {
      String filename = args[0];
      FileInputStream fis = new FileInputStream(filename);
      FileChannel channel = fis.getChannel();
      int length = (int)channel.size();
      MappedByteBuffer byteBuffer =
        channel.map(FileChannel.MapMode.READ_ONLY, 0, length);
      Charset charset = Charset.forName("ISO-8859-1");
      CharsetDecoder decoder = charset.newDecoder();
      CharBuffer charBuffer = decoder.decode(byteBuffer);
      for (int i=0, n=charBuffer.length(); i<n; i++) {
        System.out.print(charBuffer.get());
      }
    }
  }
}

眾所周知， Java在從XML文件中裝載內容到內存過程中，不論用何種方式，IO操作的開銷都無可避免。本文嘗試比較dom4j中的XPP3和SAX兩種方式裝載XML文件的性能，以便將IO操作的開銷降到最小！

package gz.lwm;

import java.io.File;
import org.apache.log4j.Logger;
import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XPP3Reader;

public class TestDom4j {
 private static final Logger log = Logger.getLogger(TestDom4j.class);
 private static long bt; 
 
 public static void main(String[] args) {
  Document doc = DocumentHelper.createDocument();   
  //先運行getXmlSAX()
  bt = System.currentTimeMillis();
  String strXml = getXmlSAX("xml/test.xml");
  if(log.isDebugEnabled()){
   log.debug("\ngetXmlSAX() use time: " + (System.currentTimeMillis() - bt) + " millis\n");
  }

  //再運行getXmlXPP3()
  bt = System.currentTimeMillis();
  String s1 =getXmlXPP3("xml/test.xml");
  if(log.isDebugEnabled()){
   log.debug("\ngetXmlXPP3() use time: " + (System.currentTimeMillis() - bt) + " millis\n");
  }
  
  
 }
 
 public static String getXmlSAX(String xmlFile){
  String result = "";
  try {
   SAXReader reader = new SAXReader();
   Document document = reader.read(new File(xmlFile));
   result = document.asXML();
  } catch (Exception e) {
   e.printStackTrace();
  }
  return result;
 }
 
 public static String getXmlXPP3(String xmlFile){
  String result = "";
  try {
   XPP3Reader reader = new XPP3Reader();
   Document document = reader.read(new File(xmlFile));
   result = document.asXML();
  } catch (Exception e) {
   e.printStackTrace();
  }
  return result;
 }

 
}

有沒有這一句"Document doc = DocumentHelper.createDocument()",對性能的影響很大,特別是對大xml文件(盡管并沒有使用doc)

另外， getXmlXSAX()和getXmlXPP3()運行的先后次序對性能的影響也很大！

測試：
    在我的機器上，對一個100k左右的XML文件進行多次測試后的均值結果為：

    getXmlXPP3() use time: 265 millis
    ...
    getXmlXSAX() use time: 359 millis
    ...

結論：
    通過比較，在讀取XML文件上，XPP3略為優于SAX！


注意：

要運行例子，classpath需包含：
dom4j-1.6.1.jar
jaxen-1.1-beta-10.jar
log4j-1.2.9.jar
pull-parser-2.1.10.jar
xpp3-1.1.4c.jar


參考：
dom4j :  http://www.dom4j.org/
XPP   :  http://www.extreme.indiana.edu/xgws/xsoap/xpp/

   Namespace namespace ...

   //第一種方法
   Document doc = DocumentHelper.createDocument();
   Element root = doc.addElement("Root", namespace.getURI());
   Element eResultMessage = root.addElement("ResultMessage");

   結果為:
   <Root xmlns="http://aaaaaa"><ResultMessage>...</ResultMessage></Root>



   //第二種方法
   Document doc = DocumentHelper.createDocument();
   Element root = doc.addElement(("Root");
   root.add(namespace);
   Element eResultMessage = root.addElement("ResultMessage");
   
   結果為:
   <Root xmlns="http://aaaaaa"><ResultMessage xmlns="">...</ResultMessage></Root>