Вывести целое число в двоичном формате на Java

У меня есть номер, и я хочу напечатать его в двоичном виде. Я не хочу делать это, написав алгоритм. Есть ли встроенная функция для этого в Java?

Предполагая, что вы имеете в виду «встроенный»:

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

Смотрите документацию Integer .

( Longимеет аналогичный метод, BigIntegerимеет метод экземпляра, где вы можете указать основание.)

Здесь нет необходимости зависеть только от двоичного или любого другого формата ... доступна одна гибкая встроенная функция, которая печатает любой формат, который вы хотите в вашей программе. Integer.toString (int, presentation);

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

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

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

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

Мне нужно было что-то, чтобы красиво распечатать вещи и разделить биты каждый 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));
}

Старая школа:

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

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 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 как 17, то результат будет: 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 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.
}

Здесь уже есть хорошие ответы на этот вопрос. Но я попробовал именно так (и, может быть, это самая простая логика на основе → по модулю / делить / добавить ):

        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

Вопрос сложен в Java (и, вероятно, также на другом языке).

Целое число представляет собой 32-битный подписанный тип данных, но Integer.toBinaryString () возвращает строковое представление целочисленного аргумента как беззнаковое целое число в базе 2.

Таким образом, Integer.parseInt (Integer.toBinaryString (X), 2) может генерировать исключение (со знаком или без знака).

Безопасный способ - использовать Integer.toString (X, 2); это создаст что-то менее элегантное:

-11110100110

Но это работает !!!

Я думаю, что это самый простой алгоритм (для тех, кто не хочет использовать встроенные функции):

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();
  }

Пример:

convertNumber (1) -> "0b1"

convertNumber (5) -> "0b101"

convertNumber (117) -> "0b1110101"

Как это работает: цикл while перемещает число вправо (заменяя последний бит на второй-последний и т. Д.), Получает значение последнего бита и помещает его в StringBuilder, повторяет до тех пор, пока не останется ни одного бита (вот когда а = 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

    }

Попробуйте так:

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 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());
    }
}

Поскольку ответ не принят, возможно, ваш вопрос был о том, как сохранить целое число в двоичном файле. java.io.DataOutputStream может быть то, что вы ищете: https://docs.oracle.com/javase/8/docs/api/java/io/DataOutputStream.html

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

Вы можете использовать битовую маску (1 << k) и выполнять операцию AND с номером! 1 << k имеет один бит в позиции k!

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();
}

Он работает со значениями со знаком и без знака, использует мощные битовые манипуляции и генерирует первые нули слева.

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();
    }