轉自（http://hi.baidu.com/cyhjason/blog/item/f599548a948282759e2fb49d.html）
有關“字節序”的描述
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) >> ;
??? 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;
}

}

字節序（通信有用）