在 Java 中，我可以定义二进制格式的整数常量吗？
声明：本页面是StackOverFlow热门问题的中英对照翻译，遵循CC BY-SA 4.0协议，如果您需要使用它，必须同样遵循CC BY-SA许可，注明原文地址和作者信息，同时你必须将它归于原作者（不是我）：StackOverFlow
原文地址: http://stackoverflow.com/questions/867365/
Warning: these are provided under cc-by-sa 4.0 license. You are free to use/share it, But you must attribute it to the original authors (not me):
StackOverFlow
In Java, can I define an integer constant in binary format?
提问by Aaron Fi
Similar to how you can define an integer constant in hexadecimal or octal, can I do it in binary?
类似于如何以十六进制或八进制定义整数常量，我可以用二进制来定义吗？
I admit this is a really easy (and stupid) question. My google searches are coming up empty.
我承认这是一个非常简单（而且愚蠢）的问题。我的谷歌搜索结果是空的。
采纳答案by Cameron McKenzie
So, with the release of Java SE 7, binary notation comes standard out of the box. The syntax is quite straight forward and obvious if you have a decent understanding of binary:
因此，随着 Java SE 7 的发布，二进制表示法成为开箱即用的标准。如果您对二进制有很好的理解，则语法非常简单明了：
byte fourTimesThree = 0b1100;
byte data = 0b0000110011;
short number = 0b111111111111111;
int overflow = 0b10101010101010101010101010101011;
long bow = 0b101010101010101010101010101010111L;
And specifically on the point of declaring class level variables as binaries, there's absolutely no problem initializing a static variable using binary notation either:
特别是在将类级别变量声明为二进制文件时，使用二进制符号初始化静态变量绝对没有问题：
public static final int thingy = 0b0101;
Just be careful not to overflow the numbers with too much data, or else you'll get a compiler error:
小心不要用太多数据溢出数字，否则你会得到一个编译器错误：
byte data = 0b1100110011; // Type mismatch: cannot convert from int to byte
Now, if you really want to get fancy, you can combine that other neat new feature in Java 7 known as numeric literals with underscores. Take a look at these fancy examples of binary notation with literal underscores:
现在，如果你真的想变得更有趣，你可以将 Java 7 中的另一个简洁的新特性称为数字文字和下划线。看看这些带有文字下划线的二进制符号的花哨示例：
int overflow = 0b1010_1010_1010_1010_1010_1010_1010_1011;
long bow = 0b1__01010101__01010101__01010101__01010111L;
Now isn't that nice and clean, not to mention highly readable?
现在是不是很好很干净，更不用说高度可读了？
I pulled these code snippets from a little article I wrote about the topic over at TheServerSide. Feel free to check it out for more details:
我从我在 TheServerSide 上写的一篇关于该主题的小文章中提取了这些代码片段。请随时查看更多详细信息：
Java 7 and Binary Notation: Mastering the OCP Java Programmer (OCPJP) Exam
回答by Ed S.
There are no binary literals in Java, but I suppose that you could do this (though I don't see the point):
Java 中没有二进制文字，但我想您可以这样做（尽管我不明白这一点）：
int a = Integer.parseInt("10101010", 2);
回答by Pierre
Search for "Java literals syntax" on Google and you come up with some entries.
在 Google 上搜索“Java 文字语法”，您会得到一些条目。
There is an octal syntax (prefix your number with 0), decimal syntax and hexadecimal syntax with a "0x" prefix. But no syntax for binary notation.
有八进制语法（用 0 前缀您的数字）、十进制语法和带有“0x”前缀的十六进制语法。但是没有二进制表示法的语法。
Some examples:
一些例子：
int i = 0xcafe ; // hexadecimal case
int j = 045 ; // octal case
int l = 42 ; // decimal case
回答by NSherwin
Slightly more awkward answer:
比较尴尬的回答：
public class Main {
public static void main(String[] args) {
byte b = Byte.parseByte("10", 2);
Byte bb = new Byte(b);
System.out.println("bb should be 2, value is \"" + bb.intValue() + "\"" );
}
}
which outputs [java] bb should be 2, value is "2"
其中输出 [java] bb 应为 2，值为“2”
回答by chgman
The answer from Ed Swangren
Ed Swangren 的回答
public final static long mask12 =
Long.parseLong("00000000000000000000100000000000", 2);
works fine. I used longinstead of intand added the modifiers to clarify possible usage as a bit mask. There are, though, two inconveniences with this approach.
工作正常。我使用了long代替int并添加了修饰符来阐明作为位掩码的可能用法。但是，这种方法有两个不便之处。
- The direct typing of all those zeroes is error prone
- The result is not available in decimal or hex format at the time of development
- 直接输入所有这些零很容易出错
- 结果在开发时没有十进制或十六进制格式
I can suggest alternative approach
我可以建议替代方法
public final static long mask12 = 1L << 12;
This expression makes it obvious that the 12th bit is 1 (the count starts from 0, from the right to the left); and when you hover mouse cursor, the tooltip
这个表达式很明显第12位是1（从0开始计数，从右到左）；当您悬停鼠标光标时，工具提示
long YourClassName.mask12 = 4096 [0x1000]
appears in Eclipse. You can define more complicated constants like:
出现在 Eclipse 中。您可以定义更复杂的常量，例如：
public final static long maskForSomething = mask12 | mask3 | mask0;
or explicitly
或明确
public final static long maskForSomething = (1L<<12)|(1L<<3)|(1L<<0);
The value of the variable maskForSomethingwill still be available in Eclipse at development time.
maskForSomething在开发时，该变量的值在 Eclipse 中仍然可用。
回答by Russ Hayward
In Java 7:
在 Java 7 中：
int i = 0b10101010;
There are no binary literals in older versions of Java (see other answers for alternatives).
旧版本的 Java 中没有二进制文字（请参阅其他答案以获取替代方案）。
回答by Anthony Hayward
If you want to mess around with lots of binary you could define some constants:
如果你想处理大量二进制文件，你可以定义一些常量：
public static final int BIT_0 = 0x00000001;
public static final int BIT_1 = 0x00000002;
etc.
等等。
or
或者
public static final int B_00000001 = 0x00000001;
public static final int B_00000010 = 0x00000002;
public static final int B_00000100 = 0x00000004;
回答by pawelzieba
Using binary constants to masking
使用二进制常量进行屏蔽
Declare constants:
声明常量：
public static final int FLAG_A = 1 << 0;
public static final int FLAG_B = 1 << 1;
public static final int FLAG_C = 1 << 2;
public static final int FLAG_D = 1 << 3;
and use them
并使用它们
if( (value & ( FLAG_B | FLAG_D )) != 0){
// value has set FLAG_B and FLAG_D
}
