在Java中以二进制格式打印整数

假设你指的是“内置”:

int x = 100;
System.out.println(Integer.toBinaryString(x));

看到整数的文档。

(Long有一个类似的方法，BigInteger有一个实例方法，你可以在其中指定基数。)

System.out.println(Integer.toBinaryString(343));

这里不需要只依赖二进制或任何其他格式…一个灵活的内置功能，打印任何格式，你想在你的程序..Integer.toString(int, representation)

Integer.toString(100,8) // prints 144 --octal representation


Integer.toString(100,2) // prints 1100100 --binary representation


Integer.toString(100,16) //prints 64 --Hex representation

古老的学校:

    int value = 28;
for(int i = 1, j = 0; i < 256; i = i << 1, j++)
System.out.println(j + " " + ((value & i) > 0 ? 1 : 0));

输出(最低有效位在0位置):

0 0
1 0
2 1
3 1
4 1
5 0
6 0
7 0

看看这个逻辑可以把一个数字转换成任何进制

public static void toBase(int number, int base) {
String binary = "";
int temp = number/2+1;
for (int j = 0; j < temp ; j++) {
try {
binary += "" + number % base;


number /= base;
} catch (Exception e) {
}
}
for (int j = binary.length() - 1; j >= 0; j--) {
System.out.print(binary.charAt(j));
}
}

或

StringBuilder binary = new StringBuilder();
int n=15;
while (n>0) {
if((n&1)==1){
binary.append(1);
}else
binary.append(0);
n>>=1;
}
System.out.println(binary.reverse());

我需要一些东西可以很好地打印出来，并把每n位的比特分开。换句话说，显示前导零并显示如下内容:

n = 5463
output = 0000 0000 0000 0000 0001 0101 0101 0111

我是这么写的:

/**
* Converts an integer to a 32-bit binary string
* @param number
*      The number to convert
* @param groupSize
*      The number of bits in a group
* @return
*      The 32-bit long bit string
*/
public static String intToString(int number, int groupSize) {
StringBuilder result = new StringBuilder();


for(int i = 31; i >= 0 ; i--) {
int mask = 1 << i;
result.append((number & mask) != 0 ? "1" : "0");


if (i % groupSize == 0)
result.append(" ");
}
result.replace(result.length() - 1, result.length(), "");


return result.toString();
}

像这样调用它:

public static void main(String[] args) {
System.out.println(intToString(5463, 4));
}

这个问题在java中很棘手(可能在其他语言中也是如此)。

Integer是一个32位的签署数据类型，但Integer. tobinarystring()返回整数参数的字符串表示形式，以2为基数的无符号整数。

因此，Integer.parseInt(Integer.toBinaryString(X)，2)可以生成一个异常(有符号vs无符号)。

安全的方法是使用Integer.toString(X,2);这将生成一些不那么优雅的东西:

-11110100110

但它确实有效!!

它使用强大的位操作处理有符号和无符号值，并生成左边的第一个零。

public static String representDigits(int num) {


int checkBit = 1 << (Integer.SIZE * 8 - 2 );    // avoid the first digit
StringBuffer sb = new StringBuffer();


if (num < 0 ) {     // checking the first digit
sb.append("1");
} else {
sb.append("0");
}


while(checkBit != 0) {
if ((num & checkBit) == checkBit){
sb.append("1");
} else {
sb.append("0");
}
checkBit >>= 1;
}


return sb.toString();
}

我认为这是迄今为止最简单的算法(对于那些不想使用内置函数的人来说):

public static String convertNumber(int a)  {
StringBuilder sb=new StringBuilder();
sb.append(a & 1);
while ((a>>=1) != 0)  {
sb.append(a & 1);
}
sb.append("b0");
return sb.reverse().toString();
}

例子:

__abc0——> __abc1

__abc0——> __abc1

__abc0——> __abc1

工作原理: while-loop将一个数字向右移动(将最后一位替换为倒数第二位，等等)，获取最后一位的值并将其放入StringBuilder中，重复直到没有剩余位(此时a=0)。

    for(int i = 1; i <= 256; i++)
{
System.out.print(i + " "); //show integer
System.out.println(Integer.toBinaryString(i) + " "); //show binary
System.out.print(Integer.toOctalString(i) + " "); //show octal
System.out.print(Integer.toHexString(i) + " "); //show hex


}

这是打印一个整数的内部二进制表示法的简单的方法。 例如:如果我们将n作为17，那么输出将是:0000 0000 0000 0000 0000 0000 0001 0001

void bitPattern(int n) {


int mask = 1 << 31;
int count = 0;
while(mask != 0) {
if(count%4 == 0)
System.out.print(" ");


if((mask&n) == 0)


System.out.print("0");






else
System.out.print("1");




count++;
mask = mask >>> 1;




}
System.out.println();
}

试试这个方法:

public class Bin {
public static void main(String[] args) {
System.out.println(toBinary(0x94, 8));
}


public static String toBinary(int a, int bits) {
if (--bits > 0)
return toBinary(a>>1, bits)+((a&0x1)==0?"0":"1");
else
return (a&0x1)==0?"0":"1";
}

｝

10010100

对于这个问题，这里已经有了很好的答案。但是，这是我自己尝试过的方法(并且可能是最简单的基于→模/分/添加的逻辑):

        int decimalOrBinary = 345;
StringBuilder builder = new StringBuilder();


do {
builder.append(decimalOrBinary % 2);
decimalOrBinary = decimalOrBinary / 2;
} while (decimalOrBinary > 0);


System.out.println(builder.reverse().toString()); //prints 101011001

给定int x的左填充零的二进制表示:

org.apache.commons.lang3.StringUtils.leftPad(Integer.toBinaryString(x), 32, '0')

输入任何十进制数作为输入。在此之后，我们进行模运算和除法运算，将给定的输入转换为二进制数。 这是Java程序的源代码，将整数值转换为二进制和他的十进制数的二进制位数。 Java程序编译成功并在Windows系统上运行。

    public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int integer ;
String binary = "";    //   here we count "" or null
//   just String binary = null;
System.out.print("Enter the binary Number: ");
integer = sc.nextInt();


while(integer>0)
{
int x = integer % 2;
binary = x + binary;
integer = integer / 2;
}
System.out.println("Your binary number is : "+binary);
System.out.println("your binary length : " + binary.length());
}
}

public static void main(String[] args)
{
int i = 13;
short s = 13;
byte b = 13;


System.out.println("i: " + String.format("%32s",
Integer.toBinaryString(i)).replaceAll(" ", "0"));


System.out.println("s: " + String.format("%16s",
Integer.toBinaryString(0xFFFF & s)).replaceAll(" ", "0"));


System.out.println("b: " + String.format("%8s",
Integer.toBinaryString(0xFF & b)).replaceAll(" ", "0"));


}

输出:

i: 00000000000000000000000000001101
s: 0000000000001101
b: 00001101

试试吧。如果作用域仅打印给定整数值的二进制值。它可以是正的，也可以是负的。

      public static void printBinaryNumbers(int n) {
char[] arr = Integer.toBinaryString(n).toCharArray();
StringBuilder sb = new StringBuilder();
for (Character c : arr) {
sb.append(c);
}
System.out.println(sb);
}

输入

5

输出

101

解决方案使用32位显示掩码，

public static String toBinaryString(int n){


StringBuilder res=new StringBuilder();
//res= Integer.toBinaryString(n); or
int displayMask=1<<31;
for (int i=1;i<=32;i++){
res.append((n & displayMask)==0?'0':'1');
n=n<<1;
if (i%8==0) res.append(' ');
}


return res.toString();
}




System.out.println(BitUtil.toBinaryString(30));




O/P:
00000000 00000000 00000000 00011110

简单又简单的解决方法。

public static String intToBinaryString(int integer, int numberOfBits) {


if (numberOfBits > 0) {     // To prevent FormatFlagsConversionMismatchException.


String nBits = String.format("%" + numberOfBits + "s",      // Int to bits conversion
Integer.toBinaryString(integer))
.replaceAll(" ","0");


return nBits;   // returning the Bits for the given int.
}


return null;        // if the numberOfBits is not greater than 0, returning null.
}

DataOutputStream os = new DataOutputStream(outputStream);
os.writeInt(42);
os.flush();
os.close();

可以使用位掩码(1<<k)，用数字做and运算! 1 & lt; & lt;K在K位有1位!< / p >

private void printBits(int x) {
for(int i = 31; i >= 0; i--) {
if((x & (1 << i)) != 0){
System.out.print(1);
}else {
System.out.print(0);
}
}
System.out.println();
}

Integer.toString(value,numbersystem)——使用的语法 并传递值

Integer.toString(100,8) //打印144—八进制

Integer.toString(100,2) //打印1100100—二进制

Integer.toString(100,16) //打印64—十六进制

这是我格式化Integer.toBinaryString方法输出的方法:

public String toBinaryString(int number, int groupSize) {
String binary = Integer.toBinaryString(number);


StringBuilder result = new StringBuilder(binary);
for (int i = 1; i < binary.length(); i++) {
if (i % groupSize == 0) {
result.insert(binary.length() - i, " ");
}
}
return result.toString();
}

字符串长= String.format(“% 64 s" Long.toBinaryString (k)。替换(',' 0 ');< / p >

String long1 = String.format("%64 "，Long.toBinaryString(k))。替换(' ',' 0 ').replaceAll(“(\ d{8})“,“1美元“); ｀ 打印: 0000000000000000000000000000000000000000000 < / p >

00000000 00000000 00000000 00000000