「javabit操作」Java中bit
今天给各位分享javabit操作的知识，其中也会对Java中bit进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！
本文目录一览：
JAVA位运算符
位操作符（bitwise operator）
位操作符允许我们操作一个基本数据类型中的整数型值的单个“比特（bit）”，即二进制位。
位操作符会对两个参数对应的位执行布尔代数运算，并最终生成一个结果。
位操作符来源于 C 语言面向底层的操作，那时我们经常需要直接操纵硬件，设置硬件寄存
器内的二进制位。Java的设计初衷是嵌入电视机顶盒内，所以这种低级操作仍被保留了下来。
但是，我们可能不会过多地使用到位运算符。
如果两个输入位都是 1，则按位“与”操作符（）生成一个输出位 1；否则生成一个输出
位0。如果两个输入位里只要有一个是1，则按位“或”操作符（|）生成一个输出位1；只
有在两个输入位都是0的情况下，它才会生成一个输出位0。如果两个输入位的某一个是1，
但不全都是1，那么“异或”操作（^）生成一个输出位1。按位“非”（~ ，也称为取补运
算，ones compliement operator ）属于一元操作符；它只对一个操作数进行操作（其他位操
作是二元运算）。按位“非”生成与输入位相反的值——若输入0，则输出1；输入1，则输
出0。
位操作符和逻辑操作符都使用了同样的符号。因此，我们能方便地记住它们的含义：由于“位”
是非常“小”的，所以位操作符仅使用了一位符号。
位操作符可与等号（=）联合使用，以便合并运算操作和赋值操作：=，|=和^=都是合法
的（由于~是一元操作符，所以不可与=联合使用）。
我们将布尔类型（boolean）作为一种“单比特”值对待，所以它多少有些独特的地方。我们
可对它执行按位“与”、“或”和“异或”运算，但不能执行按位“非”（大概是为了避免与
逻辑 NOT 混淆）。对于布尔值，位操作符具有与逻辑操作符相同的效果，只是它们不会中
途“短路”。此外，针对布尔值进行的按位运算为我们新增了一个“异或”逻辑操作符，它并
未包括在“逻辑”操作符的列表中。在移位表达式中，我们被禁止使用布尔运算，原因将在下
面解释。
移位操作符（shift operator）
移位操作符操作的运算对象也是二进制的“位”，但是它们只可以被用来处理整数类型（基本
类型的一种）。左移位操作符（）能将操作符左边的运算对象向左移动操作符右侧指定的
位数（在低位补 0）。“有符号”右移位操作符（）则将操作符左边的运算对象向右移动操
作符右侧指定的位数。“有符号”右移位操作符使用了“符号扩展”：若符号为正，则在高位插
入0；若符号为负，则在高位插入1。Java中增加了一种“无符号”右移位操作符（），它
使用了“零扩展”：无论正负，都在高位插入0。这一操作符是C或C++没有的。
如果对char、byte或者short类型的数值进行移位处理，那么在移位进行之前，它们会自动
转换为int，并且得到的结果也是一个int类型的值。而右侧操作数，作为真正移位的位数，
只有其二进制表示中的低5位才有用。这样可防止我们移位超过int型值所具有的位数。（译
注：因为2的5次方为32，而int型值只有32位）。若对一个long类型的数值进行处理，
最后得到的结果也是long。此时只会用到右侧操作数的低6位，以防止移位超过long型数
值具有的位数。
移位可与等号（=或=或=）组合使用。此时，操作符左边的值会移动由右边的值指
定的位数，再将得到的结果赋回左边的变量。但在进行“无符号”右移结合赋值操作时，可能
会遇到一个问题：如果对byte或short值进行这样的移位运算，得到的可能不是正确的结果。
它们会先被转换成int类型，再进行右移操作。然后被截断，赋值给原来的类型，在这种情
况下可能得到-1的结果。下面这个例子演示了这种情况：
//: c03:URShift.java
// Test of unsigned right shift.
import com.bruceeckel.simpletest.*;
public class URShift {
static Test monitor = new Test();
public static void main(String[] args) {
int i = -1;
System.out.println(i = 10);
long l = -1;
System.out.println(l = 10);
short s = -1;
System.out.println(s = 10);
byte b = -1;
System.out.println(b = 10);
b = -1;
System.out.println(b10);
monitor.expect(new String[] {
"4194303",
"18014398509481983",
"-1",
"-1",
"4194303"
});
}
} ///:~
在最后一个移位运算中，结果没有赋回给b，而是直接打印出来，所以其结果是正确的。
下面这个例子向大家阐示了如何应用涉及“按位”操作的所有操作符：
//: c03:BitManipulation.java
// Using the bitwise operators.
import com.bruceeckel.simpletest.*;
import java.util.*;
public class BitManipulation {
static Test monitor = new Test();
public static void main(String[] args) {
Random rand = new Random();
int i = rand.nextInt();
int j = rand.nextInt();
printBinaryInt("-1", -1);
printBinaryInt("+1", +1);
int maxpos = 2147483647;
printBinaryInt("maxpos", maxpos);
int maxneg = -2147483648;
printBinaryInt("maxneg", maxneg);
printBinaryInt("i", i);
printBinaryInt("~i", ~i);
printBinaryInt("-i", -i);
printBinaryInt("j", j);
printBinaryInt("i j", i j);
printBinaryInt("i | j", i | j);
printBinaryInt("i ^ j", i ^ j);
printBinaryInt("i 5", i 5);
printBinaryInt("i 5", i 5);
printBinaryInt("(~i) 5", (~i) 5);
printBinaryInt("i 5", i 5);
printBinaryInt("(~i) 5", (~i) 5);
long l = rand.nextLong();
long m = rand.nextLong();
printBinaryLong("-1L", -1L);
printBinaryLong("+1L", +1L);
long ll = 9223372036854775807L;
printBinaryLong("maxpos", ll);
long lln = -9223372036854775808L;
printBinaryLong("maxneg", lln);
printBinaryLong("l", l);
printBinaryLong("~l", ~l);
printBinaryLong("-l", -l);
printBinaryLong("m", m);
printBinaryLong("l m", l m);
printBinaryLong("l | m", l | m);
printBinaryLong("l ^ m", l ^ m);
printBinaryLong("l 5", l 5);
printBinaryLong("l 5", l 5);
printBinaryLong("(~l) 5", (~l) 5);
printBinaryLong("l 5", l 5);
printBinaryLong("(~l) 5", (~l) 5);
monitor.expect("BitManipulation.out");
}
static void printBinaryInt(String s, int i) {
System.out.println(
s + ", int: " + i + ", binary: ");
System.out.print(" ");
for(int j = 31; j = 0; j--)
if(((1 j) i) != 0)
System.out.print("1");
else
System.out.print("0");
System.out.println();
}
static void printBinaryLong(String s, long l) {
System.out.println(
s + ", long: " + l + ", binary: ");
System.out.print(" ");
for(int i = 63; i = 0; i--)
if(((1L i) l) != 0)
System.out.print("1");
else
System.out.print("0");
System.out.println();
}
} ///:~
程序末尾调用了两个方法：printBinaryInt()和printBinaryLong()。它们分别接受
一个 int 或 long 值的参数，并用二进制格式输出，同时附有简要的说明文字。你可以暂
时忽略它们具体是如何实现的。
请注意这里是用 System.out.print()，而不是 System.out.println()。print()方法不自动换行，所
以我们能在同一行里输出多个信息。
上面的例子中，expect() 以一个文件名作参数，它会从这个文件中读取预期的行（其中
可以有，也可以没有正则表达式）。对于那些太长，不适宜列在书里的输出，这种做法很有
用。这个文件的扩展名是“.out”，是所发布的代码的一部分，可以从下
载。如果有兴趣的话，可以打开这个文件，看看正确的输出应该是什么（或者你自己直接运
行一下前面这个程序）。
上面的例子展示了对int和long的所有按位运算的效果，还展示了int和long的最小值、最
大值、+1和-1值，以及它们的二进制形式，以使大家了解它们在机器中的具体形式。注意，
最高位表示符号：0为正，1为负。下面列出例子中关于int部分的输出：
-1, int: -1, binary:
11111111111111111111111111111111
+1, int: 1, binary:
00000000000000000000000000000001
maxpos, int: 2147483647, binary:
01111111111111111111111111111111
maxneg, int: -2147483648, binary:
10000000000000000000000000000000
i, int: 59081716, binary:
00000011100001011000001111110100
~i, int: -59081717, binary:
11111100011110100111110000001011
-i, int: -59081716, binary:
11111100011110100111110000001100
j, int: 198850956, binary:
00001011110110100011100110001100
i j, int: 58720644, binary:
00000011100000000000000110000100
i | j, int: 199212028, binary:
00001011110111111011101111111100
i ^ j, int: 140491384, binary:
00001000010111111011101001111000
i 5, int: 1890614912, binary:
01110000101100000111111010000000
i 5, int: 1846303, binary:
00000000000111000010110000011111
(~i) 5, int: -1846304, binary:
11111111111000111101001111100000
i 5, int: 1846303, binary:
00000000000111000010110000011111
(~i) 5, int: 132371424, binary:
00000111111000111101001111100000
数字的二进制表示形式被称为“有符号的2的补码”。
java,一道关于bit操作的题
楼上匿名仁兄最大的错误就是，前提并不知道应该把第几位的1变成0。
最后的算法应该是这种：
public int[] changeBit(int input); // 仅输入操作数即得到结果
算法：
用按位与操作
public class ChangeBit {
private static int[] ints = new int[13];
/**
* 初始化
*/
public ChangeBit() {
// initInts[0] = Integer.parseInt("1111111111110", 2);
// initInts[1] = Integer.parseInt("1111111111101", 2);
// initInts[2] = Integer.parseInt("1111111111011", 2);
// initInts[3] = Integer.parseInt("1111111110111", 2);
// initInts[5] = Integer.parseInt("1111111011111", 2);
// ......
// 下面的循环代替以上，实现了初始化，但以上看起来直观些
char[] full = {'1', '1', '1', '1', '1', '1', '1', '1', '1', '1', '1', '1', '1'};
for (int i = 0; i 13; i++) {
char[] temp = full.clone();
temp[i] = '0';
ints[i] = Integer.parseInt(String.valueOf(temp), 2);
}
}
/**
* 主方法
*/
public static void main(String[] args) {
new ChangeBit().doBit(13); // 输入
}
/**
* 算法
*/
public static void doBit(int input) {
for (int i = 0; i 13; i++) {
int result = input ints[i]; // 关键
if (result != input) {
System.out.println(result); // 输出
}
}
}
}
如果存在效率问题，会是初始化部分，因为涉及字符数组和字符串操作。
一旦new一次后，连续使用n次doBit方法（比特位操作），几乎就不存在效率问题了。
是acm上的题吗？time out?
java bit怎么调
能够只使用 1 个 bit 存储信息的就只有 boolean 型的布尔真假值类型，但是它的值就只有 true 或者 false，强制性转换成数字也就只有 0 和 1，你不可能写出其他数字的，而且这样写数字比你轻松地定义一个 int 型的数据要麻烦地多。
顺便附上一个数据类型占用存储空间大小的表格：
类型 占用 bit（位）
byte（字节） 8
short（短整型） 16
int（整型） 32
long（长整型） 64
float（单精度浮点型） 32
double（双精度浮点型） 64
char（字符） 16
boolean（布尔型） 1
另外如果你是要计算的话，所有参与计算的整数都会被转换成 int 类型，所有参与计算的小数都会被转换成 double 类型，所以真的没有必要，也没有办法一个位一个位地写数字。
javabit操作的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于Java中bit、javabit操作的信息别忘了在本站进行查找喔。
发布于：2022-12-16，除非注明，否则均为原创文章，转载请注明出处。