java基本数据类型转换成byte[]数组

[java] view plain copy print ?

1. package com.mystudypro.byteutil;  
2.   
3. import java.io.UnsupportedEncodingException;  
4.   
5. public class ConToByte {  
6.   
7.     /** 
8.      * double转换byte 
9.      * @param  arr  byte[] 
10.      * @param  param    double   double类型的参数 
11.      * @param  index  int 
12.      */  
13.     public static void putDouble(byte[] arr, double param, int index) {  
14.         int len = (index - 1) + 8;  
15.         int arrLen = arr.length;  
16.         boolean b = isOutOfArrLength(arrLen, len);   //判断当前数组长度是否大于转换的数组长度   
17.         Long l = Double.doubleToLongBits(param);  
18.         if (b) {   
19.             for (int i = 7; i >=0; i--) {  
20.                 arr[index + i] = l.byteValue();  
21.                 l = l >> 8;  
22.             }  
23.         } else {  
24.             // 如果当前数组长度小于转换的数组长度，就根据index截取转换的数组元素   
25.              l = l>>(8*index);  
26.             for(int j= arrLen-index-1;j>=0;j--){   
27.                 arr[index+j] = l.byteValue();  
28.                 l = l>>8;  
29.             }  
30.         }  
31.   
32.     }  
33.   
34.     /** 
35.      * float转换byte 
36.      *  
37.      * @param  arr   byte[] 
38.      * @param  param    float  float类型的参数 
39.      * @param  index  int 
40.      */  
41.     public static void putFloat(byte[] arr, float param, int index) {  
42.         int len = (index - 1) + 4;  
43.         int arrLen = arr.length;  
44.         boolean b = isOutOfArrLength(arrLen, len);    //判断当前数组长度是否大于转换的数组长度   
45.         int l = Float.floatToIntBits(param);  
46.         if (b) {  
47.             for (int i = 3; i >=0; i--) {  
48.                 arr[index + i] = new Integer(l).byteValue();  
49.                 l = l >> 8;  
50.             }  
51.         } else {  
52.             // 如果当前数组长度小于转换的数组长度，就根据index截取转换的数组元素   
53.             l = l>>(8*index);  
54.             for(int j=arrLen-index-1;j>=0;j--){   
55.                 arr[index+j] =  new Integer(l).byteValue();  
56.                  l =l>>8;  
57.             }  
58.         }  
59.   
60.     }  
61.   
62.     /** 
63.      * 字符到字节转换 
64.      *  
65.      * @param  arr   byte[] 
66.      * @param  ch     char   char类型的参数 
67.      * @param  index   int 
68.      * @return 
69.      */  
70.     public static void putChar(byte[] arr, char ch, int index) {  
71.         int len = (index - 1) + 4;  
72.         boolean b = isOutOfArrLength(arr.length, len);      //判断当前数组长度是否大于转换的数组长度   
73.         if (b) {  
74.             int temp = (int) ch;  
75.             for (int i = 1; i >=0; i--) {  
76.                 arr[index + i] = new Integer(temp & 0xff).byteValue();  
77.                 temp = temp >> 8;  
78.             }  
79.         }  
80.   
81.     }  
82.   
83.     /** 
84.      * 转换long型为byte数组 
85.      *  
86.      * @param  arr  byte[] 
87.      * @param  param    long 
88.      * @param  index  int 
89.      */  
90.     public static void putLong(byte[] arr, long param, int index) {  
91.         int len = (index - 1) + 8;  
92.         int arrLen = arr.length;  
93.         boolean b = isOutOfArrLength(arrLen, len);    //判断当前数组长度是否大于转换的数组长度   
94.         if (b) {  
95.             arr[index + 0] = (byte) ((param >> 56) & 0xff);  
96.             arr[index + 1] = (byte) ((param >> 48) & 0xff);  
97.             arr[index + 2] = (byte) ((param >> 40) & 0xff);  
98.             arr[index + 3] = (byte) ((param >> 32) & 0xff);  
99.             arr[index + 4] = (byte) ((param >> 24) & 0xff);  
100.             arr[index + 5] = (byte) ((param >> 16) & 0xff);  
101.             arr[index + 6] = (byte) ((param >> 8) & 0xff);  
102.             arr[index + 7] = (byte) (param & 0xff);  
103.         } else {  
104.             // 如果当前数组长度小于转换的数组长度，就根据index截取转换的数组元素   
105.             param = param >> (8*index);  
106.               for(int i=arrLen-index-1;i>=0;i--){  
107.                   arr[index+i] =  (byte) (param & 0xff);  
108.                   param = param >> 8;  
109.               }  
110.         }  
111.   
112.     }  
113.   
114.     /** 
115.      * int类型转换成byte数组 
116.      *  
117.      * @param arr byte[] 
118.      * @param param  int int类型的参数 
119.      * @param index  int 
120.      */  
121.     public static void putInt(byte[] arr, int param, int index) {  
122.         int len = (index - 1) + 4;  
123.         boolean b = isOutOfArrLength(arr.length, len);     //判断当前数组长度是否大于转换的数组长度   
124.         if (b) {  
125.             arr[index + 0] = (byte) ((param >> 24) & 0xff);  
126.             arr[index + 1] = (byte) ((param >> 16) & 0xff);  
127.             arr[index + 2] = (byte) ((param >> 8) & 0xff);  
128.             arr[index + 3] = (byte) (param & 0xff);  
129.         }  
130.     }  
131.   
132.     /** 
133.      * short类型转换成byte数组 
134.      *  
135.      * @param arr   byte[] 
136.      * @param param  short 
137.      * @param index  int 
138.      */  
139.     public static void putShort(byte[] arr, short param, int index) {  
140.         int len = (index - 1) + 2;  
141.         boolean b = isOutOfArrLength(arr.length, len);        //判断当前数组长度是否大于转换的数组长度   
142.         if (b) {   
143.             arr[index + 0] = (byte) ((param >> 8) & 0xff);  
144.             arr[index + 1] = (byte) (param & 0xff);  
145.         }  
146.     }  
147.   
148.     /** 
149.      * 字符串转换成byte数组 
150.      *  
151.      * @param arr  byte[] 
152.      * @param str  String 
153.      * @param index  int 
154.      * @throws java.io.UnsupportedEncodingException 
155.      */  
156.     public static void putString(byte[] arr, String str, int index) {  
157.   
158.         try {  
159.             byte[] bb = str.getBytes("GBK");  
160.             int len = index + bb.length;  
161.             boolean b = isOutOfArrLength(arr.length, len);  
162.             if (b) {  
163.                 for (int i = 0; i < bb.length; i++) {  
164.                     arr[index + i] = bb[i];  
165.                 }  
166.             } else {  
167.                 // 如果当前数组长度小于转换的数组长度，就根据index截取转换的数组元素   
168.                 for(int j=0;j<arr.length-index;j++){  
169.                     arr[index+j] = bb[j];  
170.                 }  
171.             }  
172.         } catch (UnsupportedEncodingException e) {  
173.             e.printStackTrace();  
174.         }  
175.   
176.     }  
177.   
178.     /** 
179.      * 判断数组下标是否越界 
180.      *  
181.      * @param arrLength 
182.      *            数组总长度 
183.      * @param index 
184.      *            数组偏移量 
185.      * @return 
186.      */  
187.     public static boolean isOutOfArrLength(int arrLength, int index) {  
188.         boolean b;  
189.         if (arrLength > index) {  
190.             b = true;  
191.         } else {  
192.             b = false;  
193.         }  
194.         return b;  
195.     }  
196. }  

package com.mystudypro.byteutil;

import java.io.UnsupportedEncodingException;

public class ConToByte {

	/**
	 * double转换byte
	 * @param  arr  byte[]
	 * @param  param    double   double类型的参数
	 * @param  index  int
	 */
	public static void putDouble(byte[] arr, double param, int index) {
		int len = (index - 1) + 8;
        int arrLen = arr.length;
		boolean b = isOutOfArrLength(arrLen, len);   //判断当前数组长度是否大于转换的数组长度
        Long l = Double.doubleToLongBits(param);
		if (b) { 
			for (int i = 7; i >=0; i--) {
                arr[index + i] = l.byteValue();
				l = l >> 8;
			}
		} else {
            // 如果当前数组长度小于转换的数组长度，就根据index截取转换的数组元素
             l = l>>(8*index);
            for(int j= arrLen-index-1;j>=0;j--){ 
                arr[index+j] = l.byteValue();
                l = l>>8;
            }
        }

	}

	/**
	 * float转换byte
	 * 
	 * @param  arr   byte[]
	 * @param  param    float  float类型的参数
	 * @param  index  int
	 */
	public static void putFloat(byte[] arr, float param, int index) {
		int len = (index - 1) + 4;
        int arrLen = arr.length;
		boolean b = isOutOfArrLength(arrLen, len);    //判断当前数组长度是否大于转换的数组长度
        int l = Float.floatToIntBits(param);
		if (b) {
			for (int i = 3; i >=0; i--) {
				arr[index + i] = new Integer(l).byteValue();
				l = l >> 8;
			}
		} else {
            // 如果当前数组长度小于转换的数组长度，就根据index截取转换的数组元素
            l = l>>(8*index);
            for(int j=arrLen-index-1;j>=0;j--){ 
                arr[index+j] =  new Integer(l).byteValue();
                 l =l>>8;
            }
        }

	}

	/**
	 * 字符到字节转换
	 * 
	 * @param  arr   byte[]
	 * @param  ch     char   char类型的参数
	 * @param  index   int
	 * @return
	 */
	public static void putChar(byte[] arr, char ch, int index) {
		int len = (index - 1) + 4;
		boolean b = isOutOfArrLength(arr.length, len);      //判断当前数组长度是否大于转换的数组长度
		if (b) {
			int temp = (int) ch;
			for (int i = 1; i >=0; i--) {
				arr[index + i] = new Integer(temp & 0xff).byteValue();
				temp = temp >> 8;
			}
		}

	}

	/**
	 * 转换long型为byte数组
	 * 
	 * @param  arr  byte[]
	 * @param  param    long
	 * @param  index  int
	 */
	public static void putLong(byte[] arr, long param, int index) {
		int len = (index - 1) + 8;
        int arrLen = arr.length;
		boolean b = isOutOfArrLength(arrLen, len);    //判断当前数组长度是否大于转换的数组长度
		if (b) {
			arr[index + 0] = (byte) ((param >> 56) & 0xff);
			arr[index + 1] = (byte) ((param >> 48) & 0xff);
            arr[index + 2] = (byte) ((param >> 40) & 0xff);
            arr[index + 3] = (byte) ((param >> 32) & 0xff);
            arr[index + 4] = (byte) ((param >> 24) & 0xff);
            arr[index + 5] = (byte) ((param >> 16) & 0xff);
            arr[index + 6] = (byte) ((param >> 8) & 0xff);
            arr[index + 7] = (byte) (param & 0xff);
		} else {
            // 如果当前数组长度小于转换的数组长度，就根据index截取转换的数组元素
            param = param >> (8*index);
              for(int i=arrLen-index-1;i>=0;i--){
                  arr[index+i] =  (byte) (param & 0xff);
                  param = param >> 8;
              }
        }

	}

	/**
	 * int类型转换成byte数组
	 * 
	 * @param arr byte[]
	 * @param param  int int类型的参数
	 * @param index  int
	 */
	public static void putInt(byte[] arr, int param, int index) {
		int len = (index - 1) + 4;
		boolean b = isOutOfArrLength(arr.length, len);     //判断当前数组长度是否大于转换的数组长度
		if (b) {
			arr[index + 0] = (byte) ((param >> 24) & 0xff);
			arr[index + 1] = (byte) ((param >> 16) & 0xff);
			arr[index + 2] = (byte) ((param >> 8) & 0xff);
			arr[index + 3] = (byte) (param & 0xff);
		}
	}

	/**
	 * short类型转换成byte数组
	 * 
	 * @param arr   byte[]
	 * @param param  short
	 * @param index  int
	 */
	public static void putShort(byte[] arr, short param, int index) {
		int len = (index - 1) + 2;
		boolean b = isOutOfArrLength(arr.length, len);        //判断当前数组长度是否大于转换的数组长度
		if (b) { 
			arr[index + 0] = (byte) ((param >> 8) & 0xff);
			arr[index + 1] = (byte) (param & 0xff);
		}
	}

	/**
	 * 字符串转换成byte数组
	 * 
	 * @param arr  byte[]
	 * @param str  String
	 * @param index  int
	 * @throws java.io.UnsupportedEncodingException
	 */
	public static void putString(byte[] arr, String str, int index) {

		try {
            byte[] bb = str.getBytes("GBK");
			int len = index + bb.length;
			boolean b = isOutOfArrLength(arr.length, len);
			if (b) {
				for (int i = 0; i < bb.length; i++) {
					arr[index + i] = bb[i];
				}
			} else {
                // 如果当前数组长度小于转换的数组长度，就根据index截取转换的数组元素
                for(int j=0;j<arr.length-index;j++){
                    arr[index+j] = bb[j];
                }
            }
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}

	}

	/**
	 * 判断数组下标是否越界
	 * 
	 * @param arrLength
	 *            数组总长度
	 * @param index
	 *            数组偏移量
	 * @return
	 */
	public static boolean isOutOfArrLength(int arrLength, int index) {
		boolean b;
		if (arrLength > index) {
			b = true;
		} else {
			b = false;
		}
		return b;
	}
}