java byte数组类_【Java】字节数组转换工具类

1 importorg.apache.commons.lang.ArrayUtils;2

3 importjava.nio.charset.Charset;4

5 /**

6 * 字节数组转换工具类7 */

8 public classBytesUtils {9

10 public static final String GBK = "GBK";11 public static final String UTF8 = "utf-8";12 public static final char[] ascii = "0123456789ABCDEF".toCharArray();13 private static char[] HEX_VOCABLE = { '0', '1', '2', '3', '4', '5', '6',14 '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};15

16 /**

17 * 将short整型数值转换为字节数组18 *19 *@paramdata20 *@return

21 */

22 public static byte[] getBytes(shortdata) {23 byte[] bytes = new byte[2];24 bytes[0] = (byte) ((data & 0xff00) >> 8);25 bytes[1] = (byte) (data & 0xff);26 returnbytes;27 }28

29 /**

30 * 将字符转换为字节数组31 *32 *@paramdata33 *@return

34 */

35 public static byte[] getBytes(chardata) {36 byte[] bytes = new byte[2];37 bytes[0] = (byte) (data >> 8);38 bytes[1] = (byte) (data);39 returnbytes;40 }41

42 /**

43 * 将布尔值转换为字节数组44 *45 *@paramdata46 *@return

47 */

48 public static byte[] getBytes(booleandata) {49 byte[] bytes = new byte[1];50 bytes[0] = (byte) (data ? 1 : 0);51 returnbytes;52 }53

54 /**

55 * 将整型数值转换为字节数组56 *57 *@paramdata58 *@return

59 */

60 public static byte[] getBytes(intdata) {61 byte[] bytes = new byte[4];62 bytes[0] = (byte) ((data & 0xff000000) >> 24);63 bytes[1] = (byte) ((data & 0xff0000) >> 16);64 bytes[2] = (byte) ((data & 0xff00) >> 8);65 bytes[3] = (byte) (data & 0xff);66 returnbytes;67 }68

69 /**

70 * 将long整型数值转换为字节数组71 *72 *@paramdata73 *@return

74 */

75 public static byte[] getBytes(longdata) {76 byte[] bytes = new byte[8];77 bytes[0] = (byte) ((data >> 56) & 0xff);78 bytes[1] = (byte) ((data >> 48) & 0xff);79 bytes[2] = (byte) ((data >> 40) & 0xff);80 bytes[3] = (byte) ((data >> 32) & 0xff);81 bytes[4] = (byte) ((data >> 24) & 0xff);82 bytes[5] = (byte) ((data >> 16) & 0xff);83 bytes[6] = (byte) ((data >> 8) & 0xff);84 bytes[7] = (byte) (data & 0xff);85 returnbytes;86 }87

88 /**

89 * 将float型数值转换为字节数组90 *91 *@paramdata92 *@return

93 */

94 public static byte[] getBytes(floatdata) {95 int intBits =Float.floatToIntBits(data);96 returngetBytes(intBits);97 }98

99 /**

100 * 将double型数值转换为字节数组101 *102 *@paramdata103 *@return

104 */

105 public static byte[] getBytes(doubledata) {106 long intBits =Double.doubleToLongBits(data);107 returngetBytes(intBits);108 }109

110 /**

111 * 将字符串按照charsetName编码格式的字节数组112 *113 *@paramdata114 * 字符串115 *@paramcharsetName116 * 编码格式117 *@return

118 */

119 public static byte[] getBytes(String data, String charsetName) {120 Charset charset =Charset.forName(charsetName);121 returndata.getBytes(charset);122 }123

124 /**

125 * 将字符串按照GBK编码格式的字节数组126 *127 *@paramdata128 *@return

129 */

130 public static byte[] getBytes(String data) {131 returngetBytes(data, GBK);132 }133

134 /**

135 * 将字节数组第0字节转换为布尔值136 *137 *@parambytes138 *@return

139 */

140 public static boolean getBoolean(byte[] bytes) {141 return bytes[0] == 1;142 }143

144 /**

145 * 将字节数组的第index字节转换为布尔值146 *147 *@parambytes148 *@paramindex149 *@return

150 */

151 public static boolean getBoolean(byte[] bytes, intindex) {152 return bytes[index] == 1;153 }154

155 /**

156 * 将字节数组前2字节转换为short整型数值157 *158 *@parambytes159 *@return

160 */

161 public static short getShort(byte[] bytes) {162 return (short) ((0xff00 & (bytes[0] << 8)) | (0xff & bytes[1]));163 }164

165 /**

166 * 将字节数组从startIndex开始的2个字节转换为short整型数值167 *168 *@parambytes169 *@paramstartIndex170 *@return

171 */

172 public static short getShort(byte[] bytes, intstartIndex) {173 return (short) ((0xff00 & (bytes[startIndex] << 8)) | (0xff & bytes[startIndex + 1]));174 }175

176 /**

177 * 将字节数组前2字节转换为字符178 *179 *@parambytes180 *@return

181 */

182 public static char getChar(byte[] bytes) {183 return (char) ((0xff00 & (bytes[0] << 8)) | (0xff & bytes[1]));184 }185

186 /**

187 * 将字节数组从startIndex开始的2个字节转换为字符188 *189 *@parambytes190 *@paramstartIndex191 *@return

192 */

193 public static char getChar(byte[] bytes, intstartIndex) {194 return (char) ((0xff00 & (bytes[startIndex] << 8)) | (0xff & bytes[startIndex + 1]));195 }196

197 /**

198 * 将字节数组前4字节转换为整型数值199 *200 *@parambytes201 *@return

202 */

203 public static int getInt(byte[] bytes) {204 return (0xff000000 & (bytes[0] << 24) | (0xff0000 & (bytes[1] << 16))205 | (0xff00 & (bytes[2] << 8)) | (0xff & bytes[3]));206 }207

208 /**

209 * 将字节数组从startIndex开始的4个字节转换为整型数值210 *211 *@parambytes212 *@paramstartIndex213 *@return

214 */

215 public static int getInt(byte[] bytes, intstartIndex) {216 return (0xff000000 & (bytes[startIndex] << 24)217 | (0xff0000 & (bytes[startIndex + 1] << 16))218 | (0xff00 & (bytes[startIndex + 2] << 8)) | (0xff & bytes[startIndex + 3]));219 }220

221 /**

222 * 将字节数组前8字节转换为long整型数值223 *224 *@parambytes225 *@return

226 */

227 public static long getLong(byte[] bytes) {228 return (0xff00000000000000L & ((long) bytes[0] << 56)229 | (0xff000000000000L & ((long) bytes[1] << 48))230 | (0xff0000000000L & ((long) bytes[2] << 40))231 | (0xff00000000L & ((long) bytes[3] << 32))232 | (0xff000000L & ((long) bytes[4] << 24))233 | (0xff0000L & ((long) bytes[5] << 16))234 | (0xff00L & ((long) bytes[6] << 8)) | (0xffL & (long) bytes[7]));235 }236

237 /**

238 * 将字节数组从startIndex开始的8个字节转换为long整型数值239 *240 *@parambytes241 *@paramstartIndex242 *@return

243 */

244 public static long getLong(byte[] bytes, intstartIndex) {245 return (0xff00000000000000L & ((long) bytes[startIndex] << 56)246 | (0xff000000000000L & ((long) bytes[startIndex + 1] << 48))247 | (0xff0000000000L & ((long) bytes[startIndex + 2] << 40))248 | (0xff00000000L & ((long) bytes[startIndex + 3] << 32))249 | (0xff000000L & ((long) bytes[startIndex + 4] << 24))250 | (0xff0000L & ((long) bytes[startIndex + 5] << 16))251 | (0xff00L & ((long) bytes[startIndex + 6] << 8)) | (0xffL & (long) bytes[startIndex + 7]));252 }253

254 /**

255 * 将字节数组前4字节转换为float型数值256 *257 *@parambytes258 *@return

259 */

260 public static float getFloat(byte[] bytes) {261 returnFloat.intBitsToFloat(getInt(bytes));262 }263

264 /**

265 * 将字节数组从startIndex开始的4个字节转换为float型数值266 *267 *@parambytes268 *@paramstartIndex269 *@return

270 */

271 public static float getFloat(byte[] bytes, intstartIndex) {272 byte[] result = new byte[4];273 System.arraycopy(bytes, startIndex, result, 0, 4);274 returnFloat.intBitsToFloat(getInt(result));275 }276

277 /**

278 * 将字节数组前8字节转换为double型数值279 *280 *@parambytes281 *@return

282 */

283 public static double getDouble(byte[] bytes) {284 long l =getLong(bytes);285 returnDouble.longBitsToDouble(l);286 }287

288 /**

289 * 将字节数组从startIndex开始的8个字节转换为double型数值290 *291 *@parambytes292 *@paramstartIndex293 *@return

294 */

295 public static double getDouble(byte[] bytes, intstartIndex) {296 byte[] result = new byte[8];297 System.arraycopy(bytes, startIndex, result, 0, 8);298 long l =getLong(result);299 returnDouble.longBitsToDouble(l);300 }301

302 /**

303 * 将charsetName编码格式的字节数组转换为字符串304 *305 *@parambytes306 *@paramcharsetName307 *@return

308 */

309 public static String getString(byte[] bytes, String charsetName) {310 return newString(bytes, Charset.forName(charsetName));311 }312

313 /**

314 * 将GBK编码格式的字节数组转换为字符串315 *316 *@parambytes317 *@return

318 */

319 public static String getString(byte[] bytes) {320 returngetString(bytes, GBK);321 }322

323 /**

324 * 将16进制字符串转换为字节数组325 *326 *@paramhex327 *@return

328 */

329 public static byte[] hexStringToBytes(String hex) {330 if (hex == null || "".equals(hex)) {331 return null;332 }333 int len = hex.length() / 2;334 byte[] result = new byte[len];335 char[] chArr =hex.toCharArray();336 for (int i = 0; i < len; i++) {337 int pos = i * 2;338 result[i] = (byte) (toByte(chArr[pos]) << 4 | toByte(chArr[pos + 1]));339 }340 returnresult;341 }342

343 /**

344 * 将16进制字符串转换为字节数组345 *346 *@paramhex347 *@return

348 */

349 public static byte[] hexToBytes(String hex) {350 if (hex.length() % 2 != 0)351 throw newIllegalArgumentException(352 "input string should be any multiple of 2!");353 hex.toUpperCase();354

355 byte[] byteBuffer = new byte[hex.length() / 2];356

357 byte padding = 0x00;358 boolean paddingTurning = false;359 for (int i = 0; i < hex.length(); i++) {360 if(paddingTurning) {361 char c =hex.charAt(i);362 int index =indexOf(hex, c);363 padding = (byte) ((padding << 4) |index);364 byteBuffer[i / 2] =padding;365 padding = 0x00;366 paddingTurning = false;367 } else{368 char c =hex.charAt(i);369 int index =indexOf(hex, c);370 padding = (byte) (padding |index);371 paddingTurning = true;372 }373

374 }375 returnbyteBuffer;376 }377

378 private static int indexOf(String input, charc) {379 int index =ArrayUtils.indexOf(HEX_VOCABLE, c);380

381 if (index < 0) {382 throw new IllegalArgumentException("err input:" +input);383 }384 returnindex;385

386 }387

388 /**

389 * 将BCD编码的字节数组转换为字符串390 *391 *@parambcds392 *@return

393 */

394 public static String bcdToString(byte[] bcds) {395 if (bcds == null || bcds.length == 0) {396 return null;397 }398 byte[] temp = new byte[2 *bcds.length];399 for (int i = 0; i < bcds.length; i++) {400 temp[i * 2] = (byte) ((bcds[i] >> 4) & 0x0f);401 temp[i * 2 + 1] = (byte) (bcds[i] & 0x0f);402 }403 StringBuffer res = newStringBuffer();404 for (int i = 0; i < temp.length; i++) {405 res.append(ascii[temp[i]]);406 }407 returnres.toString();408 }409

410 /**

411 * 字节转整形412 *@paramvalue413 *@return

414 */

415 public static int bcdToInt(bytevalue){416 return ((value>>4) * 10) + (value&0x0F);417 }418

419 /**

420 * 字节数组转16进制字符串421 *@parambs422 *@return

423 */

424 public static String bytesToHex(byte[] bs) {425 StringBuilder sb = newStringBuilder();426 for (byteb : bs) {427 int high = (b >> 4) & 0x0f;428 int low = b & 0x0f;429 sb.append(HEX_VOCABLE[high]);430 sb.append(HEX_VOCABLE[low]);431 }432 returnsb.toString();433 }434

435 /**

436 * 字节数组取前len个字节转16进制字符串437 *@parambs438 *@paramlen439 *@return

440 */

441 public static String bytesToHex(byte[] bs, intlen) {442 StringBuilder sb = newStringBuilder();443 for (int i=0; i> 4) & 0x0f;446 int low = b & 0x0f;447 sb.append(HEX_VOCABLE[high]);448 sb.append(HEX_VOCABLE[low]);449 }450 returnsb.toString();451 }452 /**

453 * 字节数组偏移offset长度之后的取len个字节转16进制字符串454 *@parambs455 *@paramoffset456 *@paramlen457 *@return

458 */

459 public static String bytesToHex(byte[] bs, int offset, intlen) {460 StringBuilder sb = newStringBuilder();461 for (int i=0; i> 4) & 0x0f;464 int low = b & 0x0f;465 sb.append(HEX_VOCABLE[high]);466 sb.append(HEX_VOCABLE[low]);467 }468 returnsb.toString();469 }470 /**

471 * 字节数组转16进制字符串472 *@parambs473 *@return

474 */

475 public static String byteToHex(byteb) {476 StringBuilder sb = newStringBuilder();477 int high = (b >> 4) & 0x0f;478 int low = b & 0x0f;479 sb.append(HEX_VOCABLE[high]);480 sb.append(HEX_VOCABLE[low]);481 returnsb.toString();482 }483 /**

484 * 将字节数组取反485 *486 *@paramsrc487 *@return

488 */

489 public static String negate(byte[] src) {490 if (src == null || src.length == 0) {491 return null;492 }493 byte[] temp = new byte[2 *src.length];494 for (int i = 0; i < src.length; i++) {495 byte tmp = (byte) (0xFF ^src[i]);496 temp[i * 2] = (byte) ((tmp >> 4) & 0x0f);497 temp[i * 2 + 1] = (byte) (tmp & 0x0f);498 }499 StringBuffer res = newStringBuffer();500 for (int i = 0; i < temp.length; i++) {501 res.append(ascii[temp[i]]);502 }503 returnres.toString();504 }505

506 /**

507 * 比较字节数组是否相同508 *509 *@parama510 *@paramb511 *@return

512 */

513 public static boolean compareBytes(byte[] a, byte[] b) {514 if (a == null || a.length == 0 || b == null || b.length == 0

515 || a.length !=b.length) {516 return false;517 }518 if (a.length ==b.length) {519 for (int i = 0; i < a.length; i++) {520 if (a[i] !=b[i]) {521 return false;522 }523 }524 } else{525 return false;526 }527 return true;528 }529 /**

530 * 只比对指定长度byte531 *@parama532 *@paramb533 *@paramlen534 *@return

535 */

536 public static boolean compareBytes(byte[] a, byte[] b, intlen) {537 if (a == null || a.length == 0 || b == null || b.length == 0

538 || a.length < len || b.length

549 /**

550 * 将字节数组转换为二进制字符串551 *552 *@paramitems553 *@return

554 */

555 public static String bytesToBinaryString(byte[] items) {556 if (items == null || items.length == 0) {557 return null;558 }559 StringBuffer buf = newStringBuffer();560 for (byteitem : items) {561 buf.append(byteToBinaryString(item));562 }563 returnbuf.toString();564 }565

566 /**

567 * 将字节转换为二进制字符串568 *569 *@paramitems570 *@return

571 */

572 public static String byteToBinaryString(byteitem) {573 byte a =item;574 StringBuffer buf = newStringBuffer();575 for (int i = 0; i < 8; i++) {576 buf.insert(0, a % 2);577 a = (byte) (a >> 1);578 }579 returnbuf.toString();580 }581

582 /**

583 * 对数组a，b进行异或运算584 *585 *@parama586 *@paramb587 *@return

588 */

589 public static byte[] xor(byte[] a, byte[] b) {590 if (a == null || a.length == 0 || b == null || b.length == 0

591 || a.length !=b.length) {592 return null;593 }594 byte[] result = new byte[a.length];595 for (int i = 0; i < a.length; i++) {596 result[i] = (byte) (a[i] ^b[i]);597 }598 returnresult;599 }600

601 /**

602 * 对数组a，b进行异或运算 运算长度len603 *@parama604 *@paramb605 *@paramlen606 *@return

607 */

608 public static byte[] xor(byte[] a, byte[] b, intlen) {609 if (a == null || a.length == 0 || b == null || b.length == 0) {610 return null;611 }612 if (a.length < len || b.length

622 * 将short整型数值转换为字节数组623 *624 *@paramnum625 *@return

626 */

627 public static byte[] shortToBytes(intnum) {628 byte[] temp = new byte[2];629 for (int i = 0; i < 2; i++) {630 temp[i] = (byte) ((num >>> (8 - i * 8)) & 0xFF);631 }632 returntemp;633 }634

635 /**

636 * 将字节数组转为整型637 *638 *@paramnum639 *@return

640 */

641 public static int bytesToShort(byte[] arr) {642 int mask = 0xFF;643 int temp = 0;644 int result = 0;645 for (int i = 0; i < 2; i++) {646 result <<= 8;647 temp = arr[i] &mask;648 result |=temp;649 }650 returnresult;651 }652

653 /**

654 * 将整型数值转换为指定长度的字节数组655 *656 *@paramnum657 *@return

658 */

659 public static byte[] intToBytes(intnum) {660 byte[] temp = new byte[4];661 for (int i = 0; i < 4; i++) {662 temp[i] = (byte) ((num >>> (24 - i * 8)) & 0xFF);663 }664 returntemp;665 }666

667 /**

668 * 将整型数值转换为指定长度的字节数组669 *670 *@paramsrc671 *@paramlen672 *@return

673 */

674 public static byte[] intToBytes(int src, intlen) {675 if (len < 1 || len > 4) {676 return null;677 }678 byte[] temp = new byte[len];679 for (int i = 0; i < len; i++) {680 temp[len - 1 - i] = (byte) ((src >>> (8 * i)) & 0xFF);681 }682 returntemp;683 }684

685 /**

686 * 将字节数组转换为整型数值687 *688 *@paramarr689 *@return

690 */

691 public static int bytesToInt(byte[] arr) {692 int mask = 0xFF;693 int temp = 0;694 int result = 0;695 for (int i = 0; i < 4; i++) {696 result <<= 8;697 temp = arr[i] &mask;698 result |=temp;699 }700 returnresult;701 }702

703 /**

704 * 将long整型数值转换为字节数组705 *706 *@paramnum707 *@return

708 */

709 public static byte[] longToBytes(longnum) {710 byte[] temp = new byte[8];711 for (int i = 0; i < 8; i++) {712 temp[i] = (byte) ((num >>> (56 - i * 8)) & 0xFF);713 }714 returntemp;715 }716

717 /**

718 * 将字节数组转换为long整型数值719 *720 *@paramarr721 *@return

722 */

723 public static long bytesToLong(byte[] arr) {724 int mask = 0xFF;725 int temp = 0;726 long result = 0;727 int len = Math.min(8, arr.length);728 for (int i = 0; i < len; i++) {729 result <<= 8;730 temp = arr[i] &mask;731 result |=temp;732 }733 returnresult;734 }735

736 /**

737 * 将16进制字符转换为字节738 *739 *@paramc740 *@return

741 */

742 public static byte toByte(charc) {743 byte b = (byte) "0123456789ABCDEF".indexOf(c);744 returnb;745 }746

747 /**

748 * 功能描述：把两个字节的字节数组转化为整型数据，高位补零，例如：
749 * 有字节数组byte[] data = new byte[]{1,2};转换后int数据的字节分布如下：
750 * 00000000 00000000 00000001 00000010,函数返回258751 *@paramlenData 需要进行转换的字节数组752 *@return字节数组所表示整型值的大小753 */

754 public static int bytesToIntWhereByteLengthEquals2(bytelenData[]) {755 if(lenData.length != 2){756 return -1;757 }758 byte fill[] = new byte[]{0,0};759 byte real[] = new byte[4];760 System.arraycopy(fill, 0, real, 0, 2);761 System.arraycopy(lenData, 0, real, 2, 2);762 int len =byteToInt(real);763 returnlen;764

765 }766

767 /**

768 * 功能描述：将byte数组转化为int类型的数据769 *@parambyteVal 需要转化的字节数组770 *@return字节数组所表示的整型数据771 */

772 public static int byteToInt(byte[] byteVal) {773 int result = 0;774 for(int i = 0;i < byteVal.length;i++) {775 int tmpVal = (byteVal[i]<

791 result = result |tmpVal;792 }793 returnresult;794 }795 public static byte CheckXORSum(byte[] bData){796 byte sum = 0x00;797 for (int i = 0; i < bData.length; i++) {798 sum ^=bData[i];799 }800 returnsum;801 }802 /**

803 * 从offset开始 将后续长度为len的byte字节转为int804 *@paramdata805 *@paramoffset806 *@paramlen807 *@return

808 */

809 public static int bytesToInt(byte[] data, int offset, intlen){810 int mask = 0xFF;811 int temp = 0;812 int result = 0;813 len = Math.min(len, 4);814 for (int i = 0; i < len; i++) {815 result <<= 8;816 temp = data[offset + i] &mask;817 result |=temp;818 }819 returnresult;820 }821

822 /**

823 * byte字节数组中的字符串的长度824 *@paramdata825 *@return

826 */

827 public static int getBytesStringLen(byte[] data)828 {829 int count = 0;830 for (byteb : data) {831 if(b == 0x00)832 break;833 count++;834 }835 returncount;836 }837

838 }