java位运算在实际业务中的应用 （三）

最新推荐文章于 2022-08-11 21:03:17 发布
最新推荐文章于 2022-08-11 21:03:17 发布
阅读量255 收藏
点赞数
分类专栏： java 算法 文章标签： java 算法
原文链接：https://my.oschina.net/u/3768341/blog/3008658
版权

目录

java位运算在实际业务中的应用 引论篇（一）
java位运算在实际业务中的应用 实操篇（二）
java位运算在实际业务中的应用 番外篇（三）
java位运算在实际业务中的应用 总结篇 （四）

由于 Java 是跨平台语言，所以 JVM 表现下的基础数据字节长度其实都是一致的。

int：4 个字节。 （1个字节是8位）

short：2 个字节。

long：8 个字节。

byte：1 个字节。

float：4 个字节。

double：8 个字节。

char：2 个字节。

boolean：boolean属于布尔类型，在存储的时候不使用字节，仅仅使用 1 位来存储，范围仅仅为0和1，其字面量为true和false。

原码 反码 补码
我们已经知道了一个 int 型数值是 4 个字节。每个字节有 8 位。但对于一个 int 或者其它整数类型如 （long）的数值而言还要注意的是，它的最高位是符号位。

最高位为0表示正数。
最高位为1表示负数
原码 将一个数字转换成二进制就是这个数值的原码。
int a = 5; //原码 0000 0000 0000 0000 0000 0000 0000 0101

int b = -3; //原码 1000 0000 0000 0000 0000 0000 0000 0011

反码
分两种情况：正数和负数

正数 正数的反码就是原码。
负数 负数的反码是在原码的基础上，符号位不变 其它位都取反。
5 的原码：0000 0000 0000 0000 0000 0000 0000 0101

-3 的原码：1000 0000 0000 0000 0000 0000 0000 0011
-3 的反码：1111 1111 1111 1111 1111 1111 1111 1100

补码
仍然分正数和负数两种情况

正数 正数的补码就是原码。
负数 负数的补码在反码的基础上加1。
5 的补码：0000 0000 0000 0000 0000 0000 0000 0101

-3 的反码：1111 1111 1111 1111 1111 1111 1111 1100
-3 的补码: 1111 1111 1111 1111 1111 1111 1111 1101
计算机在进行数值运算的时候，是通过补码表示每个数值的。

通过程序运行可以验证

public class Code {
    public static void main(String[] args) {
        int a = 5;
        int b = -3;
        String formata = String.format("%032d", Integer.parseInt(Integer.toBinaryString(a)));
        System.out.println(formata);
        System.out.println(Integer.toBinaryString(b));
    }
}

运行结果

00000000000000000000000000000101
11111111111111111111111111111101

如果a和b相加

100000000000000000000000000000010 此处为33位，溢出，第一位1放弃，变为

00000000000000000000000000000010 刚好为2, 5-3=2 没毛病。

程序验证

public class Code {
    public static void main(String[] args) {
        int a = 5;
        int b = -3;
        String formata = String.format("%032d", Integer.parseInt(Integer.toBinaryString(a)));
        System.out.println(formata);
        System.out.println(Integer.toBinaryString(b));
        System.out.println(String.format("%032d",Integer.parseInt(Integer.toBinaryString(a + b))));
    }
}

运行结果

00000000000000000000000000000101
11111111111111111111111111111101
00000000000000000000000000000010

位运算符 &、|、~、^、>>、<<、>>>
& 与运算符
规则 与运算时，进行运算的两个数，从最低位到最高位，一一对应。如果某 bit 的两个数值对应的值都是 1，则结果值相应的 bit 就是 1，否则为 0.

0 & 0 = 0,
0 & 1 = 0,
1 & 1 = 1
3 & 5 = 1 这是因为 （高位0省略）

0000 0011 & 0000 0101 = 0000 0001
按照规则，将两个数值按照低位到高位一一对齐运算，因为只有第 0 位都为 1，所以计算结果为 1.

程序验证

public class Code {
    public static void main(String[] args) {
        int a = 5;
        int b = 3;
        String formata = String.format("%032d", Integer.parseInt(Integer.toBinaryString(a & b)));
        System.out.println(formata);
        System.out.println(a & b);
    }
}

运行结果

00000000000000000000000000000001
1

判断一个数的奇偶性可以对1取与运算，结果为1为奇数，0为偶数

| 或运算符
规则 或运算时，进行运算的两个数，从最低位到最高位，一一对应。如果某 bit 的两个数值对应的值只要 1 个为 1，则结果值相应的 bit 就是 1，否则为 0。

0 | 0 = 0,
0 | 1 = 1,
1 | 1 = 1
3 | 5 = 7 这是因为 （高位省略）

0000 0011 | 0000 0101 = 0000 0111

程序验证

public class Code {
    public static void main(String[] args) {
        int a = 5;
        int b = 3;
        String formata = String.format("%032d", Integer.parseInt(Integer.toBinaryString(a | b)));
        System.out.println(formata);
        System.out.println(a | b);
    }
}

运行结果

00000000000000000000000000000111
7

~ 取反运算符
规则 对操作数的每一位进行操作，1 变成 0，0 变成 1。

~5 => 0000 0101 ~ => 1111 1010
5取反后十进制数为 （高位省略）

1111 1010 （最高位为1，肯定为负数，此时为补码）
1111 1001 （补码转反码-1）
1000 0110 （反码转原码，此时为-6）

所以5取反后为-6

程序验证

public class Code {
    public static void main(String[] args) {
        int a = 5;;
        System.out.println(Integer.toBinaryString(~a));
        System.out.println(~a);
    }
}

运行结果

11111111111111111111111111111010
-6

^ 异或运算符
规则 两个操作数进行异或时，对于同一位上，如果数值相同则为 0，数值不同则为 1。

1 ^ 0 = 1,
1 ^ 1 = 0,
0 ^ 0 = 0;
3 ^ 5 = 6,这是因为 （高位省略）

0000 0011 ^ 0000 0101 = 0000 0110

程序验证

public class Code {
    public static void main(String[] args) {
        int a = 5;
        int b = 3;   
        System.out.println(String.format("%032d",Integer.parseInt(Integer.toBinaryString(a ^ b))));
        System.out.println(a ^ b);
    }
}

运行结果

00000000000000000000000000000110
6

值得注意的是 3 ^ 5 = 6,而 6 ^ 5 = 3

0000 0110 ^ 0000 0101 = 0000 0011

public class Code {
    public static void main(String[] args) {
        int a = 5;
        int b = 6;
        System.out.println(String.format("%032d",Integer.parseInt(Integer.toBinaryString(a ^ b))));
        System.out.println(a ^ b);
    }
}

运行结果

00000000000000000000000000000011
3

针对这个特性，我们可以将异或运算作为一个简单的数据加密的形式。比如，将一个mp4文件所有数值与一个种子数值进行异或得到加密后的数据，解密的时候再将数据与种子数值进行异或一次就可以了。

所以说异或运算可以作为简单的加解密运算算法。可以说很多对称加密算法都是根据异或进行扩展的，之后在DES,AES加密原理中会有说到。

右移运算符
规则 a >> b 将数值 a 的二进制数值从 0 位算起到第 b - 1 位，整体向右方向移动 b 位，符号位不变，正数高位空出来的位补数值 0，负数补1。

5 >> 1 ===>  0000 0000 0000 0101 >> 1  = 0000 0000 0000 0010 = 2
7 >> 2 ===>  0000 0000 0000 0111 >> 2  = 0000 0000 0000 0001 = 1
9 >> 3 ===>  0000 0000 0000 1001 >> 3  = 0000 0000 0000 0001 = 1
11 >> 2 ===> 0000 0000 0000 1011 >> 2 = 0000 0000 0000 0010 = 2

规律：a >> b = a / ( 2 ^ b ) ,所以 5 >> 1= 5 / 2 = 2，11 >> 2 = 11 / 4 = 2。 （此处2 ^ b为2的b次方）

我们来看一下负数的右移

-5 >> 1

1000 0000 0000 0101   （-5原码）

1111 1111 1111 1010    （-5反码）

1111 1111 1111 1011     （-5补码）

1111 1111 1111 1101      右移1位，符号位不变，负数高位补1

1111 1111 1111 1100      补码转反码

1000 0000 0000 0011     反码转原码，所以-5右移1位为-3

程序验证

public class Code {
    public static void main(String[] args) {
        int a = -5;
        System.out.println(Integer.toBinaryString(a >> 1));
        System.out.println(a >> 1);
    }
}

运行结果

11111111111111111111111111111101
-3

右移还有一个无符号右移>>>，对于正数来说，>>和>>>没有什么区别，但对于负数来说差别却是巨大的

-5 >>> 1    （此处必须使用32位来计数）

1000 0000 0000 0000 0000 0000 0000 0101    -5原码

1111 1111 1111 1111 1111 1111 1111 1010    -5反码

1111 1111 1111 1111 1111 1111 1111 1011    -5补码

0111 1111 1111 1111 1111 1111 1111 1101    无符号右移1位，高位补0

因为此时高位为0，已经为正数了，所以0111 1111 1111 1111 1111 1111 1111 1101就是结果的原码，十进制为2147483645

具体为

(2 ^ 30)+(2 ^ 29) +(2 ^ 28)+(2 ^ 27)+(2^ 26)+(2 ^ 25)+(2 ^ 24)+(2 ^ 23)+(2 ^ 22)+(2 ^ 21)+(2 ^ 20)+(2 ^ 19)+(2 ^ 18)+(2 ^ 17)+(2 ^ 16)+(2 ^ 15)+(2 ^ 14)+(2 ^ 13)+(2 ^ 12)+(2 ^ 11)+(2 ^ 10)+(2 ^ 9)+(2 ^ 8)+(2 ^ 7)+(2 ^ 6)+(2 ^ 5)+(2 ^ 4)+(2 ^ 3)+(2 ^ 2)+1 =2147483645

程序验证

public class Code {
    public static void main(String[] args) {
        int a = -5;
        System.out.println("0" + Integer.toBinaryString(a >>> 1));
        System.out.println(a >>> 1);
    }
}

运行结果

01111111111111111111111111111101
2147483645

<< 左移运算符
规则 a << b 将数值 a 的二进制数值从 0 位算起到第 b - 1 位，整体向左方向移动 b 位，符号位不变，低位空出来的位补数值 0。

5 << 1 ===>  0000 0000 0000 0101 << 1  = 0000 0000 0000 1010 = 10
7 << 2 ===>  0000 0000 0000 0111 << 2  = 0000 0000 0001 1100 = 28
9 << 3 ===>  0000 0000 0000 1001 << 3  = 0000 0000 0100 1000 = 72
11 << 2 ===> 0000 0000 0000 1011 << 2 = 0000 0000 0010 1100 = 44

规律： a << b = a * (2 ^ b) （此处2 ^ b为2的b次方）

综合上面两个可以看到，如果某个数值（正数）右移 n 位，就相当于拿这个数值去除以 2 的 n 次幂。如果某个数值（正数）左移 n 位，就相当于这个数值乘以 2 ^ n。

我们来看一下负数左移

-5 << 1

1000 0000 0000 0101   （-5原码）

1111 1111 1111 1010    （-5反码）

1111 1111 1111 1011     （-5补码）

1111 1111 1111 0110      左移1位

1111 1111 1111 0101      补码转反码

1000 0000 0000 1010      反码转原码，为-10

所以-5 << 1 = -10

程序验证

public class Code {
    public static void main(String[] args) {
        int a = -5;
        System.out.println(Integer.toBinaryString(a << 1));
        System.out.println(a << 1);
    }
}

运行结果

11111111111111111111111111110110
-10

由此看来，负数左移规律 -a << b = -a * (2 ^ b) （此处2 ^ b为2的b次方）

检测第K位是否为1 （以下运行结果均未补高位0）

已知数n，检测其第K位（右起）是否为1，可以用以下表达式:

n & (1 << k - 1) 结果为0，说明第K位为0；结果不为0，说明第K位为1。

比如我要检测965的二进制第3位是否为1

public class Code {
    public static void main(String[] args) {
        int a = 965;
        int k = 1 << 3 - 1;
        System.out.println(Integer.toBinaryString(a));
        System.out.println(Integer.toBinaryString(a & k));
    }
}

运行结果

1111000101
100

说明第3位为1

如果我要检测第4位

public class Code {
    public static void main(String[] args) {
        int a = 965;
        int k = 1 << 4 - 1;
        System.out.println(Integer.toBinaryString(a));
        System.out.println(Integer.toBinaryString(a & k));
    }
}

运行结果

1111000101
0

说明第4位为0

给一个数的第K位设置为1

对于一个给定的操作数n,设置其第k位为1，可以用

n | (1 << k - 1)

比如我要设置965的第4位为1

public class Code {
    public static void main(String[] args) {
        int a = 965;
        int k = 1 << 4 - 1;
        System.out.println(Integer.toBinaryString(a));
        System.out.println(Integer.toBinaryString(a | k));
        System.out.println(a | k);
    }
}

运行结果

1111000101
1111001101
973

第k位清零

将给定操作数n的第k位清零，可以用表达式

n & ~(1 << k - 1)

比如我要将965的第3位清零

public class Code {
    public static void main(String[] args) {
        int a = 965;
        int k = 1 << 3 - 1;
        System.out.println(Integer.toBinaryString(a));
        System.out.println(Integer.toBinaryString(a & ~k));
        System.out.println(a & ~k);
    }
}

运行结果

1111000101
1111000001
961

切换第k位（1变0,0变1）

切换给定操作数n的第k位，可以用表达式

n ^ (1 << k-1)

比如我要切换965的第4位

public class Code {
    public static void main(String[] args) {
        int a = 965;
        int k = 1 << 4 - 1;
        System.out.println(Integer.toBinaryString(a));
        System.out.println(Integer.toBinaryString(a ^ k));
        System.out.println(a ^ k);
    }
}

运行结果

1111000101
1111001101
973

切换第3位

public class Code {
    public static void main(String[] args) {
        int a = 965;
        int k = 1 << 3 - 1;
        System.out.println(Integer.toBinaryString(a));
        System.out.println(Integer.toBinaryString(a ^ k));
        System.out.println(a ^ k);
    }
}

运行结果

1111000101
1111000001
961

切换值为1的最右位

切换给定操作数n的值为1的最右位，可以使用表达式

n & n - 1

还是965

public class Code {
    public static void main(String[] args) {
        int a = 965;
        int k = a - 1;
        System.out.println(Integer.toBinaryString(a));
        System.out.println(Integer.toBinaryString(a & k));
        System.out.println(a & k);
    }
}

运行结果

1111000101
1111000100
964

隔离值为1的最右位

隔离给定操作数n的值为1的最右位，可以使用表达式n & -n.

这次我们使用966

public class Code {
    public static void main(String[] args) {
        int a = 966;
        int k = -a;
        System.out.println(Integer.toBinaryString(a));
        System.out.println(Integer.toBinaryString(a & k));
        System.out.println(a & k);
    }
}

运行结果

1111000110
10
2

最右位为1是在第2位上，所以隔离为10，末位0无意义，只是为了说明最右位为1是第2位而已。

隔离值为0的最右位

隔离给定操作数n的值为0的最右位，可以使用表达式

~n & n + 1

这次依然使用965

public class Code {
    public static void main(String[] args) {
        int a = 965;
        int k = a + 1;
        System.out.println(Integer.toBinaryString(a));
        System.out.println(Integer.toBinaryString(~a));
        System.out.println(Integer.toBinaryString(k));
        System.out.println(Integer.toBinaryString(~a & k));
        System.out.println(~a & k);
    }
}

运行结果

1111000101
11111111111111111111110000111010
1111000110
10
2

结果10仅表示最右位为0的为第2位

检查某个数是否是2的幂

给定一个数n，检查其是否满足2 ^ n（2的n次方）的形式，可以使用表达式

if (n & n - 1 == 0)

我们使用968来测试一下

public class Code {
    public static void main(String[] args) {
        int a = 968;
        int k = a - 1;
        System.out.println(Integer.toBinaryString(a));
        if ((a & k) == 0) {
            System.out.println("a是2的幂");
        }else {
            System.out.println("a不是2的幂");
        }
    }
}

运行结果

1111001000
a不是2的幂

我们用32768来测试一下

public class Code {
    public static void main(String[] args) {
        int a = 32768;
        int k = a - 1;
        System.out.println(Integer.toBinaryString(a));
        if ((a & k) == 0) {
            System.out.println("a是2的幂");
        }else {
            System.out.println("a不是2的幂");
        }
    }
}

运行结果

1000000000000000
a是2的幂

将某个数乘以2的幂

对于一个给定的数n,将其乘以2 ^ k （2的k次方），可以使用表达式

n << k

假如我们用965乘以2的5次方

public class Code {
    public static void main(String[] args) {
        int a = 965;
        int k = 5;
        System.out.println(Integer.toBinaryString(a));
        System.out.println((int)(a * Math.pow(2,k)));
        System.out.println(a << k);
    }
}

运行结果

1111000101
30880
30880

将某个数除以2的幂

给定操作数n，将其除以2 ^ k （2的k次方），可以使用表达式

n >> k

假如我们用965除以2的5次方

public class Code {
    public static void main(String[] args) {
        int a = 965;
        int k = 5;
        System.out.println(Integer.toBinaryString(a));
        System.out.println((int)(a / Math.pow(2,k)));
        System.out.println(a >> k);
    }
}

运行结果

1111000101
30
30

找到给定操作数的模

给定操作数n,计算其k（这里k一般为2的幂）的模（% k），可以使用表达式n & k - 1

取数965对2的5次方取模

public class Code {
    public static void main(String[] args) {
        int a = 965;
        int k = 5;
        System.out.println(Integer.toBinaryString(a));
        System.out.println((int)(a % Math.pow(2,k)));
        System.out.println(a & ((1 << k) - 1));
    }
}

运行结果

1111000101
5
5

位值1的计数

统计位值1的计数方法有很多种，这里主要讲2种

1、按位处理

比如计算998的二进制数中有多少个1

public class Location {
    public static void main(String[] args) {
        int n = 998;
        System.out.println(Integer.toBinaryString(n));
        int count = 0;
        while (n != 0) {
            //count总是加末位的0或者1
            count += n & 1;
            //n右移1位
            n >>= 1;
        }
        System.out.println(count);
    }
}

运行结果

1111100110
7

2、使用切换方法:n & n - 1

public class Count {
    public static void main(String[] args) {
        int n = 998;
        System.out.println(Integer.toBinaryString(n));
        int count = 0;
        while (n != 0) {
            count++;
            //n和n-1每与操作一次就会消耗掉n的一个前位1
            n &= n - 1;
        }
        System.out.println(count);
    }
}

运行结果

1111100110
7

转载于：https://my.oschina.net/u/3768341/blog/3008658

不谈源码，聊聊位运算的实际应用
老男孩的架构路
07-21 316
位运算是java中比较基础的知识，位运算的计算速度很快，jdk中不少源码都是使用位运算。但是在日常开发的过程中，我们很少会使用位运算。相比较它的计算速度的优点，它可读性不高的”缺点“似乎对于普通的业务开发来说更加突出。我们更加乐意直接使用+，-，*，/这些直接的运算符。本文将给大家介绍一种位运算在业务中的应用场景，希望能给大家带来帮助，如有不对之处，欢迎指正。本位不对位运算的基础做展开介绍，如果不熟悉位运算的基础概念的，请先自行google了解。...
Java知识点整理(API) 集合 二进制 补码
SlimShadyback的博客
11-26 403
Java API 5
java二进制补码_java基础 二进制补码
weixin_35935808的博客
02-12 863
二进制补码：1、计算机系统的内部以二进制形式存储数据。2、在Java程序中输入的十进制的数据都会被自动转换为二进制，Java内部也以二进制来进行数值运算，但返回的结果是十进制。二进制补码的原理：正数+负数=模。模：某种类型数据的总数，例如：4位二进制数的模是2^4=168位二进制数的模是2^8=256负数=模-正数，这就是逐位取反加1的原因。1、在计算机系统中，数值一律用二进制的补码来存储。2、二...
Java中二进制的原码反码补码
qq_45709187的博客
08-11 1103
2、计算机在底层存储数据的时候，一律存储的是“二进制的补码形式”。int类型的4个字节的150的二进制码是：00000000 00000000 00000000 10010110。将以上的int类型强制类型转为1个字节的byte，最终在计算机中的二进制码是：10010110。对应的二进制原码：00000000 00000000 00000000 00000001。对应的二进制补码：00000000 00000000 00000000 00000001。来说：二进制原码、反码、补码的关系。..........
java位运算在实际业务中的应用 （一）
玉楼春秋的博客
09-12 287
https://blog.csdn.net/weixin_34261739/article/details/92407752 检测第K位是否为1 （以下运行结果均未补高位0） 已知数n，检测其第K位（右起）是否为1，可以用以下表达式: n & (1 << k - 1) 结果为0，说明第K位为0；结果不为0，说明第K位为1。 比如我要检测965的二进制第3位是否为1 public static void main(String[] args) { int a =
java代码执行字符串中的逻辑运算方法
08-27
在实际应用中，我们经常需要对字符串进行逻辑运算，以满足业务需求。今天，我们将分享两种Java代码执行字符串中的逻辑运算方法，这两种方法可以满足不同的业务需求。 方式一：使用JavaScript引擎进行逻辑运算 在...
java算法的实际应用,工程中的算法应用 - 简单的三个例子
weixin_33509203的博客
03-22 1299
[TOC]前言其实这篇文章早就想写了，因为自己太懒，到现在才更新。虽然这三个例子都是最简单的算法，但是不得不说，相比较暴力的做法，确实提升了效率，也节省了程序员的时间。三个例子中用到的分别是二分查找、二维平均卷积、异步改同步。二分查找应用背景给定一个URL资源接口，如XXX_001.mp4代表视频的第一秒、XXX_002.mp4代表视频的第二秒，以此类推；如何写一个多线程爬虫，把整个视频资源快速爬...
Java-Java中的判断与关系运算教程
最新发布
11-08
在本教程中，我们将深入探讨这些概念，并了解如何在实际编程中应用它们。 首先，让我们了解一下关系运算符。Java提供了以下六种关系运算符： 1. 等于（==）：用于比较两个变量是否相等，它会返回一个布尔值（true...
java基于二进制位运算的权限管理
marksa
08-18 2630
1，什么是位运算 什么是位运算 主要是使用到“位运行符”操作，＆位与运算符，| 位或运行符。参与运算的如果是10进制数，则会被转换至2进制数参与运算，然后计算结果会再转换为10进制数输出 .2 ^ 0 = 1，相应2进数为“0001”（这里^我表示成“次方”，即：2的0次方，下同） 2 ^ 1 = 2，相应2进数为“0010” 2 ^ 2 = 4，相应2进数为“0100” 2 ^ 3 =...
JAVA与MATLAB在线路工程放样数据处理中的应用.pdf
08-15
水梦琦在“JAVA与MATLAB在线路工程放样数据处理中的应用”一文中，深入探讨了如何将JAVA和MATLAB技术应用于解决线路工程放样数据处理中存在的问题。 文章首先分析了现有线路工程放样数据计算程序中存在的弊端，指出...
java基础 二进制补码
weixin_30763397的博客
03-21 136
二进制补码： 1、计算机系统的内部以二进制形式存储数据。 2、在Java程序中输入的十进制的数据都会被自动转换为二进制，Java内部也以二进制来进行数值运算，但返回的结果是十进制。 二进制补码的原理： 正数+负数=模。 模：某种类型数据的总数，例如： 4位二进制数的模是2^4=16 8位二进制数的模是2^8=256 负数=模-正数，这就是逐位取反加1的原因。 1、在...
Java 二进制，正码、反码、补码
weixin_59730172的博客
06-29 491
正码、反码、补码 计算机底层使用的是二进制，所有数据在计算机底层都是以二进制形式保存的 ​ 二进制数分为两种： 无符号二进制，只能存储正整数 有符号二进制，可以存储正数或负数，最高位为符号位，0表示正数，1表示负数 正数5表示为00000000 00000000 00000000 00000101 负数-5表示为10000000 00000000 00000000 00000101 ​ 二进制中的原码、补码、反码 原码 原始二进制值 反码 正数：反码和原码相同，如5的反码为0000000
Java二进制，原码、反码、补码、位运算
芒果的博客
10-28 517
java二进制，原码、反码、补码、位运算 二进制计数法的概念 人们在日常生活中和生产实践中,我们接触到越来越多的数字,创造了分组计数的制度.而我们的生活中,一般采用了”满十进一”的十进制计数法, 我们现在已经熟悉并经常运用这一种计数法了.但也有采用其他计数法.如二进制,六进制,十六进制等计数法.现在就来讲一讲”二进制”和”十进制”的关系 十进制和二进制数的互化 (1)化十进制数为二进制
Java二进制补码示例
liu844133828的博客
05-09 638
二进制表示负数的问题 我们知道十进制数1的二进制码用int型表示就是0000 0000 0000 0000 0000 0000 0000 0001 二进制码实际上并不能表示负数, 因为二进制数最小就是0000 0000 0000 0000 0000 0000 0000 0000 , 所以只要有数字存在就是大于0的 但实际的计算机中, 负数的运算也是必要的, 那该怎么存储呢? 于是人们根据实...
java 字节补位,Java程序以二进制补码形式检索字节数组中的当前位
weixin_32248531的博客
03-10 460
使用该toByteArray()方法返回包含此BigInteger的二进制补码表示形式的字节数组。字节数组将按大端字节序排列：最高有效字节在第零个元素中。下面是一个以二进制补码形式检索字节数组中当前位的示例。示例importjava.math.*;publicclassDemo{publicstaticvoidmain(String[]args){//BigInteger对象Bi...
java补码运算_Java：二进制（原码、反码、补码）与位运算
weixin_39624094的博客
02-21 505
一、二进制(原码、反码、补码)二进制的最高位是符号位(“0”代表正数，“1”代表负数)；Java中没有无符号数；计算机以整数的补码进行运算；1. 原码：将一个整数转换成二进制表示以 int 类型为例，int类型占4个字节、共32位。例如，2 的原码为：00000000 00000000 00000000 00000010-2的原码为：10000000 00000000 00000000 0000...
int整数转九进制java_java将一个整数转化成二进制代码示例
weixin_39606638的博客
02-27 78
将一个整数转化成二进制的方法：1 方法1：使用biginteger类：@testpublic void test1(){biginteger b=new biginteger("10");//1010system.out.println(b.tostring(2));//0b=new biginteger("1");system.out.println(b.tostring(2));//1b=ne...
java中 字符串的补位
菜鸟要早起
07-10 4541
编号时通常会遇到0001的状况进行补“0”，利用以下方法进行补位 /** * 左补位 * @param c 补位的字符 * @param length 需要的长度 * @param target * @return */ public String flushLeft(String c, int length, String target) { String cs = ""; if(target.lengt
java 十进制转二进制 并补足长度
qq_43269506的博客
11-12 2292
java 十进制转二进制 并补足长度 /** * 十进制数转为2进制数 * @param num 十进制数 * @param size 返回的位数 （可以根据自己需求设置） * @return */ public static String decimalToBinary(int num, int size) { if (size <(Integer.SIZE - Integer.numberOfLeadingZeros(nu
理解Java中的'按位异或'运算符
在实际应用中，例如在描述中的例子2，我们可以使用按位异或运算符来加密和解密字符数据。通过对字符进行异或操作，原始数据可以被转化为密文，再次对密文进行相同的操作（异或同一密钥），则可以恢复原始数据，这在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值