在Java中转换int到二进制字符串表示?

Integer.toBinaryString(int i)

还有java.lang.Integer。toString(int i, int base)方法，如果你的代码有一天可能会处理2以外的进制(二进制)，这个方法会更合适。请记住，这个方法只给出整数i的无符号表示，如果它是负的，它将在前面加上一个负号。它不用2的补数。

还有一种方法——通过使用< em > java.lang.Integer < / em >，你可以在第二个参数指定的radix (Octal - 8, Hex - 16, Binary - 2)中获得第一个参数i的字符串表示。

 Integer.toString(i, radix)

Example_

private void getStrtingRadix() {
// TODO Auto-generated method stub
/* returns the string representation of the
unsigned integer in concern radix*/
System.out.println("Binary eqivalent of 100 = " + Integer.toString(100, 2));
System.out.println("Octal eqivalent of 100 = " + Integer.toString(100, 8));
System.out.println("Decimal eqivalent of 100 = " + Integer.toString(100, 10));
System.out.println("Hexadecimal eqivalent of 100 = " + Integer.toString(100, 16));
}

OutPut_

Binary eqivalent of 100 = 1100100
Octal eqivalent of 100 = 144
Decimal eqivalent of 100 = 100
Hexadecimal eqivalent of 100 = 64

public class Main  {


public static String toBinary(int n, int l ) throws Exception {
double pow =  Math.pow(2, l);
StringBuilder binary = new StringBuilder();
if ( pow < n ) {
throw new Exception("The length must be big from number ");
}
int shift = l- 1;
for (; shift >= 0 ; shift--) {
int bit = (n >> shift) & 1;
if (bit == 1) {
binary.append("1");
} else {
binary.append("0");
}
}
return binary.toString();
}


public static void main(String[] args) throws Exception {
System.out.println(" binary = " + toBinary(7, 4));
System.out.println(" binary = " + Integer.toString(7,2));
}
}

这是我几分钟前随便写的。希望能有所帮助!

public class Main {


public static void main(String[] args) {


ArrayList<Integer> powers = new ArrayList<Integer>();
ArrayList<Integer> binaryStore = new ArrayList<Integer>();


powers.add(128);
powers.add(64);
powers.add(32);
powers.add(16);
powers.add(8);
powers.add(4);
powers.add(2);
powers.add(1);


Scanner sc = new Scanner(System.in);
System.out.println("Welcome to Paden9000 binary converter. Please enter an integer you wish to convert: ");
int input = sc.nextInt();
int printableInput = input;


for (int i : powers) {
if (input < i) {
binaryStore.add(0);
} else {
input = input - i;
binaryStore.add(1);
}
}


String newString= binaryStore.toString();
String finalOutput = newString.replace("[", "")
.replace(" ", "")
.replace("]", "")
.replace(",", "");


System.out.println("Integer value: " + printableInput + "\nBinary value: " + finalOutput);
sc.close();
}

｝

使用内置函数:

String binaryNum = Integer.toBinaryString(int num);

如果你不想使用内置函数将int转换为二进制，那么你也可以这样做:

import java.util.*;
public class IntToBinary {
public static void main(String[] args) {
Scanner d = new Scanner(System.in);
int n;
n = d.nextInt();
StringBuilder sb = new StringBuilder();
while(n > 0){
int r = n%2;
sb.append(r);
n = n/2;
}
System.out.println(sb.reverse());
}
}

将整数转换为二进制:

import java.util.Scanner;


public class IntegerToBinary {


public static void main(String[] args) {


Scanner input = new Scanner( System.in );


System.out.println("Enter Integer: ");
String integerString =input.nextLine();


System.out.println("Binary Number: "+Integer.toBinaryString(Integer.parseInt(integerString)));
}


}

输出:

输入整数:

10

二进制数:1010

最简单的方法是检查数字是否为奇数。如果是，根据定义，它的最右二进制数将是“1”(2^0)。在我们确定这个之后，我们将数字位移到右边，并使用递归检查相同的值。

@Test
public void shouldPrintBinary() {
StringBuilder sb = new StringBuilder();
convert(1234, sb);
}


private void convert(int n, StringBuilder sb) {


if (n > 0) {
sb.append(n % 2);
convert(n >> 1, sb);
} else {
System.out.println(sb.reverse().toString());
}
}

public static string intToBinary(int n)
{
String s = "";
while (n > 0)
{
s =  ( (n % 2 ) == 0 ? "0" : "1") +s;
n = n / 2;
}
return s;
}

这应该非常简单，就像这样:

public static String toBinary(int number){
StringBuilder sb = new StringBuilder();


if(number == 0)
return "0";
while(number>=1){
sb.append(number%2);
number = number / 2;
}


return sb.reverse().toString();


}

这可以用伪代码表示为:

while(n > 0):
remainder = n%2;
n = n/2;
Insert remainder to front of a list or push onto a stack


Print list or stack

这是我的方法，它的字节数是固定的

private void printByte(int value) {
String currentBinary = Integer.toBinaryString(256 + value);
System.out.println(currentBinary.substring(currentBinary.length() - 8));
}


public int binaryToInteger(String binary) {
char[] numbers = binary.toCharArray();
int result = 0;
for(int i=numbers.length - 1; i>=0; i--)
if(numbers[i]=='1')
result += Math.pow(2, (numbers.length-i - 1));
return result;
}

你真的应该使用Integer.toBinaryString ()(如上所示)，但如果出于某种原因你想要自己的:

// Like Integer.toBinaryString, but always returns 32 chars
public static String asBitString(int value) {
final char[] buf = new char[32];
for (int i = 31; i >= 0; i--) {
buf[31 - i] = ((1 << i) & value) == 0 ? '0' : '1';
}
return new String(buf);
}

使用位移位稍微快一点…

public static String convertDecimalToBinary(int N) {


StringBuilder binary = new StringBuilder(32);


while (N > 0 ) {
binary.append( N % 2 );
N >>= 1;
}


return binary.reverse().toString();


}

public class BinaryConverter {


public static String binaryConverter(int number) {
String binary = "";
if (number == 1){
binary = "1";
return binary;
}
if (number == 0){
binary = "0";
return binary;
}
if (number > 1) {
String i = Integer.toString(number % 2);


binary = binary + i;
binaryConverter(number/2);
}
return binary;
}
}

为了使它精确到8位，我对@sandeep-saini的回答做了一点小小的补充:

public static String intToBinary(int number){
StringBuilder sb = new StringBuilder();


if(number == 0)
return "0";
while(number>=1){
sb.append(number%2);
number = number / 2;
}
while (sb.length() < 8){
sb.append("0");
}


return sb.reverse().toString();


}

所以现在对于1的输入，你得到了00000001的输出

public static String intToBinaryString(int n) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 32 && n != 0; i++) {
sb.append((n&1) == 1 ? "1" : "0");
n >>= 1;
}
return sb.reverse().toString();
}

我们不能使用n%2来检查第一个位，因为它不适合负整数。我们应该使用n&1。

如果int值为15，可以将其转换为二进制，如下所示。

int x = 15;


Integer.toBinaryString(x);

如果你有二进制值，你可以把它转换成int值，如下所示。

String binaryValue = "1010";


Integer.parseInt(binaryValue, 2);

我的2美分。

public class Integer2Binary {
public static void main(String[] args) {
final int integer12 = 12;
System.out.println(integer12 + " -> " + integer2Binary(integer12));
// 12 -> 00000000000000000000000000001100
}


private static String integer2Binary(int n) {
return new StringBuilder(Integer.toBinaryString(n))
.insert(0, "0".repeat(Integer.numberOfLeadingZeros(n)))
.toString();
}
}