050_整形和字节数组转换

于 2021-05-19 00:04:13 发布
阅读量653 收藏 2
点赞数
分类专栏： Java基础学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aihiao/article/details/117003923
版权

1. 整形和字节数组转换公式

int a = -128
byte[] b = {(byte)(a >> 24), (byte)(a >> 16) , (byte)(a >> 8) , (byte)a}
b[0] = (byte)(a >> 24)
b[0] = (byte)(a >> 16)
b[0] = (byte)(a >> 8)
b[0] = (byte)a 
int result = ((b[0] & 0xFF) << 24) | ((b[1] & 0xFF) << 16) | ((b[2] & 0xFF) << 8) | (b[3] & 0xFF) = (((byte)(a >> 24) & 0xFF) << 24) | (((byte)(a >> 16) & 0xFF) << 16) | (((byte)(a >> 8) & 0xFF) << 8) | (a & 0xFF)

2. 整形和字节数组的互相转换例子

/**
 * 整形和字节数组的互相转换, 当成公式记
 */
public class ByteArrayIntChangeStyle {
	public static void main(String[] args) {
		for(int i = Byte.MIN_VALUE * 50; i <= Byte.MAX_VALUE; i++) {
			System.out.println(i + " " + byteArrayToInt(intToByteArray(i)));
		}
	}
	
	// byte类型的数值与 0xFF按位与, 使得不关心的位全是0
public static int byteArrayToInt(byte[] b) {  
    	return  (b[0] & 0xFF) << 24 |  
    			(b[1] & 0xFF) << 16 |  
            (b[2] & 0xFF) << 8 | 
            b[3] & 0xFF;
}  
  
// 强制转换成了byte类型, 丢弃了高位, 所以与 0xFF按位与操作可有可无
public static byte[] intToByteArray(int a) {  
    	return new byte[] {  
//	        (byte) ((a >> 24) & 0xFF),  
//	        (byte) ((a >> 16) & 0xFF),     
//	        (byte) ((a >> 8) & 0xFF),     
//	        (byte) (a & 0xFF)
    		(byte) (a >> 24),  
	        (byte) (a >> 16),     
	        (byte) (a >> 8),     
	        	(byte) a
    	};  
}
	
}

3. 分析整形-1和字节数组之间的互相转换

-1的原码: 10000000 00000000 00000000 00000001

-1的反码: 11111111 11111111 11111111 11111110

-1的补码: 11111111 11111111 11111111 11111111

字节数组byte[] b = new byte[4];

3.1. b[0] = (byte) ((-1 >> 24) & 0xFF) , 存储的是-1的25-32位的数据

-1的右移24位, 高位用1填补:      11111111 11111111 11111111 11111111

0xFF的补码:                     00000000 00000000 00000000 11111111

-1和0xFF按位与:                00000000 00000000 00000000 11111111

-1和0xFF按位与, 转换成byte类型, 丢弃掉高位数据:             11111111

-1和0xFF按位与, 转换成byte类型, 反码:                       11111110

-1和0xFF按位与, 转换成byte类型, 原码:                       10000001

结果: -1

3.2. b[1] = (byte) ((-1 >> 16) & 0xFF) , 存储的是-1的17-24位的数据

-1的右移16位, 高位用1填补:      11111111 11111111 11111111 11111111

0xFF的补码:                     00000000 00000000 00000000 11111111

-1和0xFF按位与:                00000000 00000000 00000000 11111111

-1和0xFF按位与, 转换成byte类型, 丢弃掉高位数据:             11111111

-1和0xFF按位与, 转换成byte类型, 反码:                       11111110

-1和0xFF按位与, 转换成byte类型, 原码:                       10000001

结果: -1

 

3.3. b[2] = (byte) ((-1 >> 8) & 0xFF), 存储的是-1的9-16位的数据

-1的右移8位, 高位用1填补:      11111111 11111111 11111111 11111111

0xFF的补码:                     00000000 00000000 00000000 11111111

-1和0xFF按位与:                00000000 00000000 00000000 11111111

-1和0xFF按位与, 转换成byte类型, 丢弃掉高位数据:             11111111

-1和0xFF按位与, 转换成byte类型, 反码:                       11111110

-1和0xFF按位与, 转换成byte类型, 原码:                       10000001

结果: -1

3.4. b[3] = (byte) (-1 & 0xFF) , 存储的是-1的1-8位的数据

-1的补码:                       11111111 11111111 11111111 11111111

0xFF的补码:                     00000000 00000000 00000000 11111111

-1和0xFF按位与:                00000000 00000000 00000000 11111111

-1和0xFF按位与, 转换成byte类型, 丢弃掉高位数据:             11111111

-1和0xFF按位与, 转换成byte类型, 反码:                       11111110

-1和0xFF按位与, 转换成byte类型, 原码:                       10000001

结果: -1

3.5. b = {-1, -1, -1, -1}

3.6. (b[0] & 0xFF) << 24

b[0]的补码:                                                  11111111

0xFF的补码:                     00000000 00000000 00000000 11111111

b[0]和0xFF按位与:               00000000 00000000 00000000 11111111

b[0]和0xFF按位与, 左移24位, 低位0填补:

    11111111 00000000 00000000 00000000

3.7. (b[1] & 0xFF) << 16

b[1]的补码:                                                  11111111

0xFF的补码:                     00000000 00000000 00000000 11111111

b[1]和0xFF按位与:               00000000 00000000 00000000 11111111

b[1]和0xFF按位与, 左移16位, 低位0填补:

    00000000 11111111 00000000 00000000

3.8. (b[2] & 0xFF) << 8

b[2]的补码:                                                  11111111

0xFF的补码:                     00000000 00000000 00000000 11111111

b[2]和0xFF按位与:               00000000 00000000 00000000 11111111

b[2]和0xFF按位与, 左移8位, 低位0填补:

    00000000 00000000 11111111 00000000

3.9. b[3] & 0xFF

b[3]的补码:                                                  11111111

0xFF的补码:                     00000000 00000000 00000000 11111111

b[3]和0xFF按位与:               00000000 00000000 00000000 11111111

3.10. b[0] | b[1] | b[2] | b[3]

b[0]补码:                        11111111 00000000 00000000 00000000

b[1]补码:                        00000000 11111111 00000000 00000000

b[2]补码:                        00000000 00000000 11111111 00000000

b[3]补码:                        00000000 00000000 00000000 11111111

b[0] b[1] b[2] b[3]按位或操作:      11111111 11111111 11111111 11111111

b[0] b[1] b[2] b[3]按位或操作反码:  11111111 11111111 11111111 11111110

b[0] b[1] b[2] b[3]按位或操作原码:  10000000 00000000 00000000 00000001

结果: -1

4. 分析整形128和字节数组之间的互相转换

128的补码: 00000000 00000000 00000000 10000000

字节数组byte[] b = new byte[4];

4.1. b[0] = (byte) ((128 >> 24) & 0xFF) , 存储的是128的25-32位的数据

128的右移24位, 高位用0填补:    00000000 00000000 00000000 00000000

0xFF的补码:                     00000000 00000000 00000000 11111111

128和0xFF按位与:               00000000 00000000 00000000 00000000

128和0xFF按位与, 转换成byte类型, 丢弃掉高位数据:           00000000

结果: 0

4.2. b[1] = (byte) ((128 >> 16) & 0xFF) , 存储的是128的17-24位的数据

128的右移16位, 高位用0填补:    00000000 00000000 00000000 00000000

0xFF的补码:                     00000000 00000000 00000000 11111111

128和0xFF按位与:               00000000 00000000 00000000 00000000

128和0xFF按位与, 转换成byte类型, 丢弃掉高位数据:           00000000

结果: 0

4.3. b[2] = (byte) ((128 >> 8) & 0xFF), 存储的是128的9-16位的数据

128的右移8位, 高位用0填补:    00000000 00000000 00000000 00000000

0xFF的补码:                     00000000 00000000 00000000 11111111

128和0xFF按位与:               00000000 00000000 00000000 00000000

128和0xFF按位与, 转换成byte类型, 丢弃掉高位数据:           00000000

结果: 0

4.4. b[3] = (byte) (128 & 0xFF) , 存储的是128的1-8位的数据

128的补码:                      00000000 00000000 00000000 10000000

0xFF的补码:                     00000000 00000000 00000000 11111111

128和0xFF按位与:               00000000 00000000 00000000 10000000

128和0xFF按位与, 转换成byte类型, 丢弃掉高位数据:           10000000

结果: -128

4.5. b = {0, 0, 0, -128}

4.6. (b[0] & 0xFF) << 24

b[0]的补码:                                                  00000000

0xFF的补码:                     00000000 00000000 00000000 11111111

b[0]和0xFF按位与:               00000000 00000000 00000000 00000000

b[0]和0xFF按位与, 左移24位, 低位0填补:

    00000000 00000000 00000000 00000000

4.7. (b[1] & 0xFF) << 16

b[1]的补码:                                                  00000000

0xFF的补码:                     00000000 00000000 00000000 11111111

b[1]和0xFF按位与:               00000000 00000000 00000000 00000000

b[1]和0xFF按位与, 左移16位, 低位0填补:

    00000000 00000000 00000000 00000000

4.8. (b[2] & 0xFF) << 8

b[2]的补码:                                                  00000000

0xFF的补码:                     00000000 00000000 00000000 11111111

b[2]和0xFF按位与:               00000000 00000000 00000000 00000000

b[2]和0xFF按位与, 左移8位, 低位0填补:

    00000000 00000000 00000000 00000000

4.9. b[3] & 0xFF

b[3]的补码:                                                  10000000

0xFF的补码:                     00000000 00000000 00000000 11111111

b[3]和0xFF按位与:               00000000 00000000 00000000 10000000

4.10. b[0] | b[1] | b[2] | b[3]

b[0]补码:                        00000000 00000000 00000000 00000000

b[1]补码:                        00000000 00000000 00000000 00000000

b[2]补码:                        00000000 00000000 00000000 00000000

b[3]补码:                        00000000 00000000 00000000 10000000

b[0] b[1] b[2] b[3]按位或操作:      00000000 00000000 00000000 10000000

结果: 128

自由与束缚JavaJavaScript
关注
专栏目录
整形数据（int）如何转换到字节型数据（byte）的
MY博客
06-19 9343
#今天遇到了一个问题：byte a = (byte)0x86 ; System.out.println(a==0x86); //结果显示为false，我惊了个呆。。。呆然后分析一下原因： 数据类型 范围 byte -128~127 int -2,147,483,648~2,147,483,647， 在java中采用的是补码的形式，下面介绍下什么是补码1、反码：
C# 如何将字节数据转换为整型
最新发布
带你成为别人眼中的大佬！
09-02 1084
需要注意的是，当将字节数据转换为整型数据时，如果字节数据的值超出了整型数据的表示范围（0到255），将会导致溢出错误。因此，在进行转换之前最好先判断字节数据的范围是否在整型数据的表示范围之内，以避免出现错误。在C#中，我们可以使用内置的类型转换函数将字节数据(byte)转换为整型(int)。通过这种方式，我们可以将字节数据转换为整型数据，并在后续的操作中使用整型数据进行计算或其他处理。将字节数据转换为整型数据，并将结果存储在变量。函数打印出转换前的字节数据和转换后的整型数据。，它被赋值为255。
整形变量与字节数组的相互转换
一叶舟轻
11-05 3418
今天读写socket的时候遇到一种转换，要在int型变量和字节数组之间进行转换 {汗～公司定义的数据包}As is known to all，JAVA里边int是4字节存储的，于是乎想到了用移位操作来实现，同样也可以用移位操作将字节数组还原成int变量。具体代码如下：------------------------------------------------------------------
将整形转化为二进制存放着数组中
l1325175199的专栏
05-03 973
char *itobs(int n,char *ps) {  int i;  static int size=8*sizeof(int);  for(i=size-1;i>=0;i--,n>>1)   ps[i]=(01&n)+'0';//'0'表示数组结束  ps[size]='\0';  return ps; }
字节数组与整数的相互转化
tianqinglei的博客
07-28 6050
在工作的一些项目中，经常用到字节数组的整数的相互转化，现总结如下： package java.util; /** * 数据工具类 */ public class DataUtil { /** * 将整数转换成字节数组 */ public static byte[] int2ByteArr(int i){ byte[] bytes = new byte[4] ; byt
java整型转换为数组_基于java中byte数组与int类型的转换(两种方法)
weixin_28813803的博客
02-25 1108
java中byte数组与int类型的转换，在网络编程中这个算法是最基本的算法，我们都知道，在socket传输中，发送、者接收的数据都是 byte数组，但是int类型是4个byte组成的，如何把一个整形int转换成byte数组，同时如何把一个长度为4的byte数组转换为int类型。下面有两种方式。public static byte[] int2byte(int res) {byte[] targe...
字节和float转换小工具
04-15
标题中的"字节和float转换小工具"是一个专门针对字节与浮点数（float）之间转换的实用程序。这个小工具设计的目标是帮助开发者高效地在字节序列和浮点数之间进行切换，这在数据传输、存储或解析二进制文件时非常有用...
& 0xFF byte字节数组转换为十进制
热门推荐
ZeroBz的博客
08-24 1万+
byte[]  b = new byte[2]; b[0] = -12; byte     1个字节     char     2个字节   short    2个字节  int        4个字节 long     8个字节 float     4个字节 double 8个字节 计算机存储数据机制：正数存储的二进制原码,负数存储的是二进制的补码。  补码是负数的绝对值反码加...
c语言int转字节数组,C/C++知识点之C语言数据转换(hex - char - byte array - acsii)
weixin_33300389的博客
05-17 1218
本文主要向大家介绍了C/C++知识点之C语言数据转换(hex - char - byte array - acsii)，通过具体的内容向大家展示，希望对大家学习C/C++知识点有所帮助。网上的整理过来的，来源记不清了，感谢作者。DataConvert.c#include#include#include"DataConvert.h"intstrToHex(char*ch,char*he...
c++实现整型和字节数组间的转化
weixin_40583386的博客
01-09 7143
整型转换到字节数组 在网络传输中经常需要将整型数字转换成字节数组，然后将字节数组发送到客户端，在c++，int是4个字节，long是8个字节。废话不说，代码如下（byte类型是uchar）： int32_t bytesto_int4(byte *bytes) { //turn bytes array to integer int32_t num = bytes[0] &amp;...
整形数组与字符数组相互转换
07-24
3. 序列化与反序列化：将整形数组转换为字符数组的过程可以看作是序列化，即将结构化的数据转化为字节流，方便存储或传输。反之，将字符数组还原为整形数组是反序列化，即从字节流中恢复原始数据结构。 4. 数据库...
整形转字节byte数组
ab1233369ab的专栏
09-13 2037
public static byte[] intToByte(int number) { int temp = number; byte[] b=new byte[4]; for (int i=b.length-1;i>-1;i--){ b[i] = new Integer(temp&0xff).byteValue();      //将最高位保存在最低位 temp = temp >>
整型转化为Byte字节
ahesihua的博客
10-27 2797
今天被同学问到如何将整型数转换成字节类型数组，我在网上找了一些资料后，写了一个简单的测试例子： package com.inis.testframework; public class TestLongToByte { public static byte[] int2Byte(int intValue){ byte[] b=new byte[4]; f...
温习二进制（网上转的）
iteye_20037的博客
04-06 116
[size=large] 关于将byte转为int时，为啥要 & 0xFF [/size] [code="java"] byte b = -1; // 它的结果是：ffffffff Sytem.out.println( Integer.toHexString(b) ); // 它的结果是：ff System.out.println( Integer.toHe...
整型int和字节数组byte相互转换
懒人的技术笔记
01-27 1万+
<br />public class Test { public static void main(String args[] ) { int i = 212123; byte[] b = toByteArray(i, 4); //整型到字节， System.out.println( "212123 bin: " + Integer.toBinaryString(212123));//212123的二进制表示 Syst
整型变量与字节数组的相互转换
蚊子 的 专栏
11-17 1017
public class IntByteConvertor { public static byte[] int2Byte(int intValue){  byte[] b=new byte[4];  for(int i=0;i4;i++){   b[i]=(byte)(intValue>>8*(3-i) & 0xFF);   //System.out.print(
64位 int 占几个字节_简述在C语言中, 计算各数据类型所占据的字节数的方法
weixin_39633437的博客
11-23 2551
在C语言中，数据类型分为：基本数据类型，和复杂数据类型。基本数据类型包括：int、long、short、char、folat、double；复杂数据类型有：数组、结构体、枚举体。此外，还有一个较为特殊的数据类型：指针。在C语言中，检测某一个数据类型所占据的内存大小，也即：所占据的内存中的字节数，可以使用一个关键字来检测，sizeof，这个关键字，是一个运算符，与加（+）减（-）乘（*）除（/）是一...
JVM系列笔记--字节码与类加载
那股哇的博客
11-10 207
一、字节码指令 反编译 可使用javap -v className.class来反编译class文件public class Demo3_1 { public static void main(String[] args) { int a = 10; int b = Short.MAX_VALUE + 1; int c = a + b; System.out.println(c); } } Classfile /D:/dow
将一个整型转换为整型数组例如Int num = 5546798;转为int [] {5,5,4,6,7,9,8}(不能转换为字符串)...
weimou66
02-13 404
static void Main() { int number = 4563581; ArrayList array = new ArrayList(); while (number &gt; 0) { array.Add(number %...
无符号整形占多少个字节
05-30
在C语言中，`unsigned int`是一种无符号整型数据类型，它的长度是由编译器和操作系统所确定的，不同的编译器和操作系统可能会有所不同。通常情况下，`unsigned int`的长度为4个字节，即32位，可以存储0~4294967295之间的整数。这个长度可以通过`sizeof`运算符来获取，例如： ```c unsigned int x; printf("unsigned int 占用 %d 个字节\n", sizeof(x)); ``` 上面的代码中，`sizeof(x)`可以获取`unsigned int`类型的变量`x`所占用的字节数，并将结果输出到屏幕上。通常情况下，输出结果应该是4个字节。需要注意的是，`sizeof`运算符返回的是一个`size_t`类型的值，表示对象所占用的字节数，因此在输出时需要使用`%zu`格式化字符串。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值