java 0xaa_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 = 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)]

}

}