byte 为有符号数据，引用文章

android byte的使用

暴走邻家 2018-01-24 08:55:07

10333

收藏 4
分类专栏： android Android基础 文章标签： android app java byte 函数
版权

今天，简单讲讲android里byte的使用。
这个其实很简单，但是自己觉得一直没有完全弄明白，所以记录一下。
byte即字节的意思，是java中的基本类型，用心申明字节型的变量。
通常在读取非文本文件时（如图片，声音，可执行文件）需要用字节数组来保存文件的内容，在下载文件时，也是用byte数组作临时的缓冲器接收文件内容。所以说byte在文件操作时是必不可少的。不管是对文件写入还是读取都要用到。
byte在java中是一种是数据类型，代表一个字节，一个字节包含8个位，所以，byte类型的取值范围为-128到127。
在某些程序中（尤其是和硬件有关的程序）会将某些数据存储到字节类型的变量中，比如00110010,其中每个位都代表一个参数，然后以位运算的方式对参数进行取值和赋值操作。
下面介绍一些byte的相关函数：
一、实现功能
1、int与byte互转
2、int与byte[]互转
3、short与byte互转
4、short与byte[]互转
5、16位short与byte[]互转
6、long与byte[]互转
7、byte[]与inputstream互转
8、byte与String互转
9、16进制字符转int
10、十进制转2进制
11、byte[]转16进制字符
12、byte[]数组指定位置抽取byte[]
二、代码实现

1. 
   package cc.eguid.util;
3. 
   import java.io.ByteArrayInputStream;
4. 
   import java.io.ByteArrayOutputStream;
5. 
   import java.io.IOException;
6. 
   import java.io.InputStream;
7. 
   import java.io.UnsupportedEncodingException;
8. 
   import java.nio.ByteBuffer;
9. 
   /**
10. 
    * 基本数据互转工具
11. 
    * @author eguid
12. 
    eguid的官网：http://www.eguid.cc
13. 
    *eguid的csdn博客：http://blog.csdn.net/eguid_1,博客园：http://www.cnblogs.com/eguid
14. 
    */
15. 
    public class ByteUtil {
16. 
    private static ByteBuffer buffer = ByteBuffer.allocate(8);
17. 
    /**
18. 
    * int转byte
19. 
    * @param x
20. 
    * @return
21. 
    */
22. 
    public static byte intToByte(int x) {
23. 
    return (byte) x;
24. 
    }
25. 
    /**
26. 
    * byte转int
27. 
    * @param b
28. 
    * @return
29. 
    */
30. 
    public static int byteToInt(byte b) {
31. 
    //Java的byte是有符号，通过 &0xFF转为无符号
32. 
    return b & 0xFF;
33. 
    }
35. 
    /**
36. 
    * byte[]转int
37. 
    * @param b
38. 
    * @return
39. 
    */
40. 
    public static int byteArrayToInt(byte[] b) {
41. 
    return b[3] & 0xFF |
42. 
    (b[2] & 0xFF) << 8 |
43. 
    (b[1] & 0xFF) << 16 |
44. 
    (b[0] & 0xFF) << 24;
45. 
    }
46. 
    public static int byteArrayToInt(byte[] b, int index){
47. 
    return b[index+3] & 0xFF |
48. 
    (b[index+2] & 0xFF) << 8 |
49. 
    (b[index+1] & 0xFF) << 16 |
50. 
    (b[index+0] & 0xFF) << 24;
51. 
    }
52. 
    /**
53. 
    * int转byte[]
54. 
    * @param a
55. 
    * @return
56. 
    */
57. 
    public static byte[] intToByteArray(int a) {
58. 
    return new byte[] {
59. 
    (byte) ((a >> 24) & 0xFF),
60. 
    (byte) ((a >> 16) & 0xFF),
61. 
    (byte) ((a >> 8) & 0xFF),
62. 
    (byte) (a & 0xFF)
63. 
    };
64. 
    }
65. 
    /**
66. 
    * short转byte[]
67. 
    *
68. 
    * @param b
69. 
    * @param s
70. 
    * @param index
71. 
    */
72. 
    public static void byteArrToShort(byte b[], short s, int index) {
73. 
    b[index + 1] = (byte) (s >> 8);
74. 
    b[index + 0] = (byte) (s >> 0);
75. 
    }
76. 
    /**
77. 
    * byte[]转short
78. 
    *
79. 
    * @param b
80. 
    * @param index
81. 
    * @return
82. 
    */
83. 
    public static short byteArrToShort(byte[] b, int index) {
84. 
    return (short) (((b[index + 0] << 8) | b[index + 1] & 0xff));
85. 
    }
86. 
    /**
87. 
    * 16位short转byte[]
88. 
    *
89. 
    * @param s
90. 
    * short
91. 
    * @return byte[]
92. 
    * */
93. 
    public static byte[] shortToByteArr(short s) {
94. 
    byte[] targets = new byte[2];
95. 
    for (int i = 0; i < 2; i++) {
96. 
    int offset = (targets.length - 1 - i) * 8;
97. 
    targets[i] = (byte) ((s >>> offset) & 0xff);
98. 
    }
99. 
    return targets;
100. 
     }
101. 
     /**
102. 
     * byte[]转16位short
103. 
     * @param b
104. 
     * @return
105. 
     */
106. 
     public static short byteArrToShort(byte[] b){
107. 
     return byteArrToShort(b,0);
108. 
     }
110. 
     /**
111. 
     * long转byte[]
112. 
     * @param x
113. 
     * @return
114. 
     */
115. 
     public static byte[] longToBytes(long x) {
116. 
     buffer.putLong(0, x);
117. 
     return buffer.array();
118. 
     }
119. 
     /**
120. 
     * byte[]转Long
121. 
     * @param bytes
122. 
     * @return
123. 
     */
124. 
     public static long bytesToLong(byte[] bytes) {
125. 
     buffer.put(bytes, 0, bytes.length);
126. 
     buffer.flip();//need flip
127. 
     return buffer.getLong();
128. 
     }
129. 
     /**
130. 
     * 从byte[]中抽取新的byte[]
131. 
     * @param data - 元数据
132. 
     * @param start - 开始位置
133. 
     * @param end - 结束位置
134. 
     * @return 新byte[]
135. 
     */
136. 
     public static byte[] getByteArr(byte[]data,int start ,int end){
137. 
     byte[] ret=new byte[end-start];
138. 
     for(int i=0;(start+i)<end;i++){
139. 
     ret[i]=data[start+i];
140. 
     }
141. 
     return ret;
142. 
     }
144. 
     /**
145. 
     * 流转换为byte[]
146. 
     * @param inStream
147. 
     * @return
148. 
     */
149. 
     public static byte[] readInputStream(InputStream inStream) {
150. 
     ByteArrayOutputStream outStream = null;
151. 
     try {
152. 
     outStream = new ByteArrayOutputStream();
153. 
     byte[] buffer = new byte[1024];
154. 
     byte[] data = null;
155. 
     int len = 0;
156. 
     while ((len = inStream.read(buffer)) != -1) {
157. 
     outStream.write(buffer, 0, len);
158. 
     }
159. 
     data = outStream.toByteArray();
160. 
     return data;
161. 
     }catch (IOException e) {
162. 
     return null;
163. 
     } finally {
164. 
     try {
165. 
     if (outStream != null) {
166. 
     outStream.close();
167. 
     }
168. 
     if (inStream != null) {
169. 
     inStream.close();
170. 
     }
171. 
     } catch (IOException e) {
172. 
     return null;
173. 
     }
174. 
     }
175. 
     }
176. 
     /**
177. 
     * byte[]转inputstream
178. 
     * @param b
179. 
     * @return
180. 
     */
181. 
     public static InputStream readByteArr(byte[] b){
182. 
     return new ByteArrayInputStream(b);
183. 
     }
184. 
     /**
185. 
     * byte数组内数字是否相同
186. 
     * @param s1
187. 
     * @param s2
188. 
     * @return
189. 
     */
190. 
     public static boolean isEq(byte[] s1,byte[] s2){
191. 
     int slen=s1.length;
192. 
     if(slen==s2.length){
193. 
     for(int index=0;index<slen;index++){
194. 
     if(s1[index]!=s2[index]){
195. 
     return false;
196. 
     }
197. 
     }
198. 
     return true;
199. 
     }
200. 
     return false;
201. 
     }
202. 
     /**
203. 
     * byte数组转换为Stirng
204. 
     * @param s1 -数组
205. 
     * @param encode -字符集
206. 
     * @param err -转换错误时返回该文字
207. 
     * @return
208. 
     */
209. 
     public static String getString(byte[] s1,String encode,String err){
210. 
     try {
211. 
     return new String(s1,encode);
212. 
     } catch (UnsupportedEncodingException e) {
213. 
     return err==null?null:err;
214. 
     }
215. 
     }
216. 
     /**
217. 
     * byte数组转换为Stirng
218. 
     * @param s1-数组
219. 
     * @param encode-字符集
220. 
     * @return
221. 
     */
222. 
     public static String getString(byte[] s1,String encode){
223. 
     return getString(s1,encode,null);
224. 
     }
225. 
     //测试
226. 
     public static void main(String []args){
227. 
     System.err.println(isEq(new byte[]{1,2},new byte[]{1,2}));
228. 
     }
229. 
     /**
230. 
     * 字节数组转16进制字符串
231. 
     * @param b
232. 
     * @return
233. 
     */
234. 
     public static String byteArrToHexString(byte[] b){
235. 
     String result="";
236. 
     for (int i=0; i < b.length; i++) {
237. 
     result += Integer.toString( ( b[i] & 0xff ) + 0x100, 16).substring(1);
238. 
     }
239. 
     return result;
240. 
     }
242. 
     /**
243. 
     * 16进制字符创转int
244. 
     * @param hexString
245. 
     * @return
246. 
     */
247. 
     public static int hexStringToInt(String hexString){
248. 
     return Integer.parseInt(hexString,16);
249. 
     }
250. 
     /**
251. 
     * 十进制转二进制
252. 
     * @param i
253. 
     * @return
254. 
     */
255. 
     public static String intToBinary(int i){
256. 
     return Integer.toBinaryString(i);
257. 
     }
258. 
     }

android byte的使用就讲完了
就这么简单。

android byte的使用_谢岩的博客-CSDN博客​blog.csdn.net