Android/Kotlin数据操作byte16进制0xaa变为0xffffffaa的解决办法
解决办法
#kotlin
Integer.toHexString(itm.toInt() and(0xff))
#java
Integer.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<Int?> = 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<Int?> = 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)]
}
}
