个人中心
gpt4 book ai didi

java处理字节的常用工具类

转载 作者：qq735679552 更新时间：2022-09-27 22:32:09 26 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章java处理字节的常用工具类由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

处理字节的常用工具类方法，供大家参考，具体内容如下 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
package com.demo.utils;
 
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.nio.charset.Charset;
import java.util.Arrays;
 
/**
  * 处理字节的常用工具类方法
  * @author dongyangyang
  * @Date 2017/3/13 12:31
  * @Version 1.0
  *
  */
public class ByteUtils {
 
  /**
   * 构造新字节时需要与的值表
   */
  private static final byte [] BUILD_BYTE_TABLE = new byte [] { ( byte ) 128 , ( byte ) 64 , ( byte ) 32 , ( byte ) 16 , ( byte ) 8 , ( byte ) 4 , ( byte ) 2 , ( byte ) 1 };
 
  private ByteUtils() {}
 
  /**
   * short转换到字节数组
   *
   * @param number
   *   需要转换的数据。
   * @return 转换后的字节数组。
   */
  public static byte [] shortToByte( short number) {
   byte [] b = new byte [ 2 ];
   for ( int i = 1 ; i >= 0 ; i--) {
    b[i] = ( byte ) (number % 256 );
    number >>= 8 ;
   }
   return b;
  }
 
  /**
   * 字节到short转换
   *
   * @param b
   *   short的字节数组
   * @return short数值。
   */
  public static short byteToShort( byte [] b) {
   return ( short ) ((((b[ 0 ] & 0xff ) << 8 ) | b[ 1 ] & 0xff ));
  }
 
  /**
   * 整型转换到字节数组
   *
   * @param number
   *   整形数据。
   * @return 整形数据的字节数组。
   */
  public static byte [] intToByte( int number) {
   byte [] b = new byte [ 4 ];
   for ( int i = 3 ; i >= 0 ; i--) {
    b[i] = ( byte ) (number % 256 );
    number >>= 8 ;
   }
   return b;
  }
 
  /**
   * 字节数组到整型转换
   *
   * @param b
   *   整形数据的字节数组。
   * @return 字节数组转换成的整形数据。
   */
  public static int byteToInt( byte [] b) {
   return ((((b[ 0 ] & 0xff ) << 24 ) | ((b[ 1 ] & 0xff ) << 16 ) | ((b[ 2 ] & 0xff ) << 8 ) | (b[ 3 ] & 0xff )));
  }
 
  /**
   * long转换到字节数组
   *
   * @param number
   *   长整形数据。
   * @return 长整形转换成的字节数组。
   */
  public static byte [] longToByte( long number) {
   byte [] b = new byte [ 8 ];
   for ( int i = 7 ; i >= 0 ; i--) {
    b[i] = ( byte ) (number % 256 );
    number >>= 8 ;
   }
   return b;
  }
 
  /**
   * 字节数组到整型的转换
   *
   * @param b
   *   长整形字节数组。
   * @return 长整形数据。
   */
  public static long byteToLong( byte [] b) {
   return (((( long ) b[ 0 ] & 0xff ) << 56 ) | ((( long ) b[ 1 ] & 0xff ) << 48 ) | ((( long ) b[ 2 ] & 0xff ) << 40 ) | ((( long ) b[ 3 ] & 0xff ) << 32 ) | ((( long ) b[ 4 ] & 0xff ) << 24 )
     | ((( long ) b[ 5 ] & 0xff ) << 16 ) | ((( long ) b[ 6 ] & 0xff ) << 8 ) | (( long ) b[ 7 ] & 0xff ));
  }
 
  /**
   * double转换到字节数组
   *
   * @param d
   *   双精度浮点。
   * @return 双精度浮点的字节数组。
   */
  public static byte [] doubleToByte( double d) {
   byte [] bytes = new byte [ 8 ];
   long l = Double.doubleToLongBits(d);
   for ( int i = 0 ; i < bytes.length; i++) {
    bytes[i] = Long.valueOf(l).byteValue();
    l = l >> 8 ;
   }
   return bytes;
  }
 
  /**
   * 字节数组到double转换
   *
   * @param b
   *   双精度浮点字节数组。
   * @return 双精度浮点数据。
   */
  public static double byteToDouble( byte [] b) {
   long l;
   l = b[ 0 ];
   l &= 0xff ;
   l |= (( long ) b[ 1 ] << 8 );
   l &= 0xffff ;
   l |= (( long ) b[ 2 ] << 16 );
   l &= 0xffffff ;
   l |= (( long ) b[ 3 ] << 24 );
   l &= 0xffffffffl;
   l |= (( long ) b[ 4 ] << 32 );
   l &= 0xffffffffffl;
 
   l |= (( long ) b[ 5 ] << 40 );
   l &= 0xffffffffffffl;
   l |= (( long ) b[ 6 ] << 48 );
   l &= 0xffffffffffffffl;
 
   l |= (( long ) b[ 7 ] << 56 );
 
   return Double.longBitsToDouble(l);
  }
 
  /**
   * float转换到字节数组
   *
   * @param d
   *   浮点型数据。
   * @return 浮点型数据转换后的字节数组。
   */
  public static byte [] floatToByte( float d) {
   byte [] bytes = new byte [ 4 ];
   int l = Float.floatToIntBits(d);
   for ( int i = 0 ; i < bytes.length; i++) {
    bytes[i] = Integer.valueOf(l).byteValue();
    l = l >> 8 ;
   }
   return bytes;
  }
 
  /**
   * 字节数组到float的转换
   *
   * @param b
   *   浮点型数据字节数组。
   * @return 浮点型数据。
   */
  public static float byteToFloat( byte [] b) {
   int l;
   l = b[ 0 ];
   l &= 0xff ;
   l |= (( long ) b[ 1 ] << 8 );
   l &= 0xffff ;
   l |= (( long ) b[ 2 ] << 16 );
   l &= 0xffffff ;
   l |= (( long ) b[ 3 ] << 24 );
   l &= 0xffffffffl;
 
   return Float.intBitsToFloat(l);
  }
 
  /**
   * 字符串到字节数组转换
   *
   * @param s
   *   字符串。
   * @param charset
   *   字符编码
   * @return 字符串按相应字符编码编码后的字节数组。
   */
  public static byte [] stringToByte(String s, Charset charset) {
   return s.getBytes(charset);
  }
 
  /**
   * 字节数组带字符串的转换
   *
   * @param b
   *   字符串按指定编码转换的字节数组。
   * @param charset
   *   字符编码。
   * @return 字符串。
   */
  public static String byteToString( byte [] b, Charset charset) {
   return new String(b, charset);
  }
 
  /**
   * 对象转换成字节数组。
   *
   * @param obj
   *   字节数组。
   * @return 对象实例相应的序列化后的字节数组。
   * @throws IOException
   */
  public static byte [] objectToByte(Object obj) throws IOException {
   ByteArrayOutputStream buff = new ByteArrayOutputStream();
   ObjectOutputStream out = new ObjectOutputStream(buff);
   out.writeObject(obj);
   try {
    return buff.toByteArray();
   } finally {
    out.close();
   }
  }
 
  /**
   * 序死化字节数组转换成实际对象。
   *
   * @param b
   *   字节数组。
   * @return 对象。
   * @throws IOException
   * @throws ClassNotFoundException
   */
  public static Object byteToObject( byte [] b) throws IOException, ClassNotFoundException {
   ByteArrayInputStream buff = new ByteArrayInputStream(b);
   ObjectInputStream in = new ObjectInputStream(buff);
   Object obj = in.readObject();
   try {
    return obj;
   } finally {
    in.close();
   }
  }
 
  /**
   * 比较两个字节的每一个bit位是否相等.
   *
   * @param a
   *   比较的字节.
   * @param b
   *   比较的字节
   * @return ture 两个字节每一位都相等,false有至少一位不相等.
   */
  public static boolean equalsBit( byte a, byte b) {
   return Arrays.equals(byteToBitArray(a), byteToBitArray(b));
  }
 
  /**
   * 比较两个数组中的每一个字节,两个字节必须二进制字节码每一位都相同才表示两个 byte相同.
   *
   * @param a
   *   比较的字节数组.
   * @param b
   *   被比较的字节数.
   * @return ture每一个元素的每一位两个数组都是相等的,false至少有一位不相等.
   */
  public static boolean equalsBit( byte [] a, byte [] b) {
   if (a == b) {
    return true ;
   }
   if (a == null || b == null ) {
    return false ;
   }
 
   int length = a.length;
   if (b.length != length) {
    return false ;
   }
 
   for ( int count = 0 ; count < a.length; count++) {
    if (!equalsBit(a[count], b[count])) {
     return false ;
    }
   }
   return true ;
  }
 
  /**
   * 返回某个字节的bit组成的字符串.
   *
   * @param b
   *   字节.
   * @return Bit位组成的字符串.
   */
  public static String bitString( byte b) {
   StringBuilder buff = new StringBuilder();
   boolean [] array = byteToBitArray(b);
   for ( int i = 0 ; i < array.length; i++) {
    buff.append(array[i] ? 1 : 0 );
   }
   return buff.toString();
  }
 
  /**
   * 计算出给定byte中的每一位,并以一个布尔数组返回. true表示为1,false表示为0.
   *
   * @param b
   *   字节.
   * @return 指定字节的每一位bit组成的数组.
   */
  public static boolean [] byteToBitArray( byte b) {
   boolean [] buff = new boolean [ 8 ];
   int index = 0 ;
   for ( int i = 7 ; i >= 0 ; i--) {
    buff[index++] = ((b >>> i) & 1 ) == 1 ;
   }
   return buff;
  }
 
  /**
   * 返回指定字节中指定bit位,true为1,false为0. 指定的位从0-7,超出将抛出数据越界异常.
   *
   * @param b
   *   需要判断的字节.
   * @param index
   *   字节中指定位.
   * @return 指定位的值.
   */
  public static boolean byteBitValue( byte b, int index) {
   return byteToBitArray(b)[index];
  }
 
  /**
   * 根据布尔数组表示的二进制构造一个新的字节.
   *
   * @param values
   *   布尔数组,其中true表示为1,false表示为0.
   * @return 构造的新字节.
   */
  public static byte buildNewByte( boolean [] values) {
   byte b = 0 ;
   for ( int i = 0 ; i < 8 ; i++) {
    if (values[i]) {
     b |= BUILD_BYTE_TABLE[i];
    }
   }
   return b;
  }
 
  /**
   * 将指定字节中的某个bit位替换成指定的值,true代表1,false代表0.
   *
   * @param b
   *   需要被替换的字节.
   * @param index
   *   位的序号,从0开始.超过7将抛出越界异常.
   * @param newValue
   *   新的值.
   * @return 替换好某个位值的新字节.
   */
  public static byte changeByteBitValue( byte b, int index, boolean newValue) {
   boolean [] bitValues = byteToBitArray(b);
   bitValues[index] = newValue;
   return buildNewByte(bitValues);
  }
 
  /**
   * 将指定的IP地址转换成字节表示方式. IP数组的每一个数字都不能大于255,否则将抛出IllegalArgumentException异常.
   *
   * @param ipNums
   *   IP地址数组.
   * @return IP地址字节表示方式.
   */
  public static byte [] ipAddressBytes(String address) {
   if (address == null || address.length() < 0 || address.length() > 15 ) {
    throw new IllegalArgumentException( "Invalid IP address." );
   }
 
   final int ipSize = 4 ; // 最大IP位数
   final char ipSpace = '.' ; // IP数字的分隔符
   int [] ipNums = new int [ipSize];
   StringBuilder number = new StringBuilder(); // 当前操作的数字
   StringBuilder buff = new StringBuilder(address);
   int point = 0 ; // 当前操作的数字下标,最大到3.
   char currentChar;
   for ( int i = 0 ; i < buff.length(); i++) {
    currentChar = buff.charAt(i);
    if (ipSpace == currentChar) {
     // 当前位置等于最大于序号后,还有字符没有处理表示这是一个错误的IP.
     if (point == ipSize - 1 && buff.length() - (i + 1 ) > 0 ) {
      throw new IllegalArgumentException( "Invalid IP address." );
     }
     ipNums[point++] = Integer.parseInt(number.toString());
     number.delete( 0 , number.length());
    } else {
     number.append(currentChar);
    }
   }
   ipNums[point] = Integer.parseInt(number.toString());
 
   byte [] ipBuff = new byte [ipSize];
   int pointNum = 0 ;
   for ( int i = 0 ; i < 4 ; i++) {
    pointNum = Math.abs(ipNums[i]);
    if (pointNum > 255 ) {
     throw new IllegalArgumentException( "Invalid IP address." );
    }
    ipBuff[i] = ( byte ) (pointNum & 0xff );
   }
 
   return ipBuff;
  }
}

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持我.

原文链接：https://blog.csdn.net/qq_35712358/article/details/70254584 。

最后此篇关于java处理字节的常用工具类的文章就讲到这里了,如果你想了解更多关于java处理字节的常用工具类的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

26 4 0
文章推荐： java生成验证码工具类
文章推荐： 方块游戏商店限时免费领取黑暗魔法师：崛起
文章推荐： 百度地图15周年感恩有你集卡瓜分1亿好礼 9.13号统一开奖
文章推荐： 被爱情所伤女生个性签名悲痛难过 为什么眼泪会止不住的往下流
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
全站热门文章
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com