Android/Kotlin数据操作byte16进制0xaa变为0xffffffaa的解决办法
解决办法
#kotlinInteger.toHexString(itm.toInt() and(0xff))
#javaInteger.toHexString(itm.toInt() & 0xff)
以下为引用内容，方便查阅
引自https://www.cnblogs.com/cvbaka/archive/2004/01/13/4747337.html
这是因为Integer.toHexString()的接收参数是int,不是byte,于是运算是会先把byte强制转换为int
由于java中强制转换是保持值不变,而在计算机中数都是用补码表示的,java中int是32位4个byte, 正数补码是正数本身,这样不会有问题,强转为32位时前面24位会填充0,
而负数的补码是"将其对应正数二进制表示所有位取反(包括符号位，0变1，1变0)后加1",
于是32位的0x00 00 00 80(0000 ... 0000 1000 0000)补码是0xFF FF FF 80(1111 ... 1111 1000 0000),前面是填充的1
所以Integer.toHexString()后就会变成前面多了一串F
引自https://blog.csdn.net/Jamie_Jiang/article/details/78343549?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.channel_param&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.channel_param
今天学到一句Integer.toHexString(b & 0xff)(b是byte类型的)
马克一下什么意思
Integer.toHexString这个方法是把字节(转换成了int)以16进制的方式显示。
首先，
以下是java.lang.Integer.toHexString()方法的声明
public static String toHexString(int i)
其次，
&是什么
&是位操作符,“按位与”当&作为位运算时，1&1=1 ，1&0=0，0&0=0
举个栗子： a=1;b=2;a&b=0
计算方法为：
1转成二进制 01
2转成二进制 10
所以，a&b=00 转成十进制为0
然后，
0xff是什么
0x表示是十六进制。
ff是两个十六进制的数,每个f用二进制表示是1111,所以占四位(bit),两个f(ff)占八位(bit)，八位(bit)也就是一个字节(byte).
最后，
上面的这些都理解了，那么具体是怎么个流程呢？
首先toHexString传的参数应该是int类型32位，此处传的是byte类型8位，所以前面需要补24个0。然后& 0xff 就是把前面24个0去掉只要后8位。
(经过百度)int本身就是由4组byte组成，并且Java中本身就以byte读取。所以此处传参没有问题。
toHexString(b & 0xff)相当于做了一次位的与运算，将前24位字符省略，将后8位保留。即只转了后8位。即可得到两个十六进制的值。
我的理解是这样，如有不对欢迎指正！也可补充！
引自https://blog.csdn.net/u010428110/article/details/106824749/
一、位操作：
shl(bits) – 左移位 (Java’s <<)
shr(bits) – 右移位 (Java’s >>)
ushr(bits) – 无符号右移位 (Java’s >>>)
and(bits) – 与 &
or(bits) – 或 ||
xor(bits) – 异或
inv() – 反向
val a = 5 val b = a shl 2 //左移2位，5*2*2=20 println(b) //20
二、位运算符:
运算符 表示含义
and(bits) 按位与
or(bits) 按位或
inv(bits) 按位非
xor(bits) 按位异或
shl(bits) 左移运算符
shr(bits) 右移运算符
ushr(bits) 无符号右移运算符
三、Kotlin的位运算符只能对Int和Long两种数据类型起作用。
四、位操作和位运算实例
通过位运算来保证头尾不超过数组范围，通过位操作来扩容(数组长度保持为2的整数倍，方便进行位运算)
//如ArrayDeque通过位与运算(等价于java中的'&')，保证头尾不超过数组边界class SimpleIntArrayDeque { private var elements: Array = arrayOfNulls(16) //扩容数组 private var head: Int = 0 //头 private var tail: Int = elements.size //尾，tail-1是当前最后一位数据 fun addFirst(value: Int) { if (value == null) throw NullPointerException() //当head-1为-1时，实际上是11111111&00111111，结果是00111111，也就是物理数组的尾部15； head = (head - 1) and (elements.size - 1) elements[head] = value if (head == tail) doubleCapacity() } fun addLast(value: Int) { if (value == null) throw NullPointerException() elements[tail] = value //当tail+1为16时，实际上是01000000&00111111，结果是00000000，也就是物理数组的头部0； tail = (tail + 1) and (elements.size - 1) if (tail == head) doubleCapacity() } fun pollFirst(): Int? { val h = head val result = elements[h] if (result != null) { elements[h] = null head = (h + 1) and (elements.size - 1) } return result } fun pollLast(): Int? { val t = (tail - 1) and (elements.size - 1) val result = elements[t] if (result != null) { elements[t] = null tail = t } return result } //扩容：插入数据前，判断插入后将头尾相等(即插入后数组将填满)，则立即扩容 private fun doubleCapacity() { val p = head val n = elements.size val r = n - p var newCapacity = n shl 1 //扩容2倍 if (newCapacity < 0) throw IllegalArgumentException("Sorry, deque too big") var newElements: Array = arrayOfNulls(newCapacity) //从头部开始拷贝,拷贝头部以后的所有内容，并把头部位置重置为0 System.arraycopy(elements, p, newElements, 0, r) /** * 从0开始拷贝，拷贝头部之前的内容，并把拷贝内容接上刚才拷贝的位置， * 使得原来的数组放到新数组的前半部分 */ System.arraycopy(elements, 0, newElements, r, p) //释放旧的数组内存 Arrays.fill(elements, null) elements = newElements head = 0 tail = n } fun size(): Int { //插入前判断，若插入后占满则立即扩容，因此size不会大于数组长度减一 return (tail - head) and (elements.size - 1) } fun isEmpty(): Boolean { return head == tail } fun peekFirst(): Int? { return elements[head] } fun peekLast(): Int? { return elements[(tail -1) and (elements.size - 1)] }}