Wydrukuj liczbę całkowitą w formacie binarnym w Javie

Mam numer i chcę wydrukować go w formacie binarnym. Nie chcę tego robić, pisząc algorytm. Czy jest w tym jakaś wbudowana funkcja w Javie?

Zakładając, że masz na myśli „wbudowany”:

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

Zobacz dokumentację liczb całkowitych .

( Longma podobną metodę, BigIntegerma metodę instancji, w której można określić podstawę).

Tutaj nie musisz polegać tylko na formacie binarnym lub innym ... dostępna jest jedna elastyczna funkcja wbudowana, która wypisuje dowolny format w twoim programie .. Integer.toString (int, reprezentacja);

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

Potrzebowałem czegoś, aby ładnie wydrukować rzeczy i oddzielić bity co n-bit. Innymi słowy, wyświetlaj wiodące zera i pokazuj coś takiego:

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

Oto co napisałem:

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

Wywołaj to w ten sposób:

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

Stara szkoła:

    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"));

}

Wynik:

i: 00000000000000000000000000001101
s: 0000000000001101
b: 00001101

sprawdź tę logikę można przekonwertować liczbę na dowolną bazę

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

LUB

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

Jest to najprostszy sposób drukowania wewnętrznej reprezentacji binarnej liczby całkowitej. Na przykład : jeśli weźmiemy n jako 17, wynik będzie następujący: 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();
}

Po prostu spróbuj. Jeśli zakres drukuje tylko wartości binarne podanej wartości całkowitej. Może być dodatni lub ujemny.

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

Wejście

5

Wynik

101

Rozwiązanie z wykorzystaniem 32-bitowej maski wyświetlacza,

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 

Proste i najłatwiejsze rozwiązanie.

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.
}

Tutaj są już dobre odpowiedzi na to pytanie. Ale tak właśnie próbowałem (i może to być najłatwiejsza logika → modulo / divide / add ):

        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

Pytanie jest trudne w Javie (i prawdopodobnie także w innym języku).

Liczba całkowita jest 32-bitowy podpisany typ danych, ale Integer.toBinaryString () zwraca łańcuchowej reprezentacji argumentu jako całkowitą bez znaku całkowitej bazy 2.

Tak więc Integer.parseInt (Integer.toBinaryString (X), 2) może wygenerować wyjątek (podpisany vs. niepodpisany).

Bezpiecznym sposobem jest użycie Integer.toString (X, 2); wygeneruje to coś mniej eleganckiego:

-11110100110

Ale to działa !!!

Myślę, że jest to najprostszy jak dotąd algorytm (dla tych, którzy nie chcą korzystać z wbudowanych funkcji):

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

Przykład:

convertNumber (1) -> „0b1”

convertNumber (5) -> „0b101”

convertNumber (117) -> „0b1110101”

Jak to działa: pętla while przesuwa liczbę w prawo (zamieniając ostatni bit z drugiego na ostatni itd.), Pobiera wartość ostatniego bitu i umieszcza go w StringBuilder, powtarza, aż nie pozostaną żadne bity (wtedy 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

    }

Wypróbuj w ten sposób:

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

Binarna reprezentacja podanego int x z lewymi dopełnionymi zerami:

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

Wprowadź dowolną liczbę dziesiętną jako dane wejściowe. Następnie wykonujemy operacje takie jak modulo i dzielenie, aby przekonwertować dane wejściowe na liczbę binarną. Oto kod źródłowy programu Java do konwersji wartości całkowitych na binarne i liczba bitów tego pliku binarnego dla jego liczby dziesiętnej. Program Java został pomyślnie skompilowany i uruchomiony w systemie Windows. Wyjście programu pokazano również poniżej.

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

Ponieważ odpowiedź nie jest akceptowana, być może twoje pytanie dotyczyło sposobu zapisania liczby całkowitej w pliku binarnym. java.io.DataOutputStream może być tym, czego szukasz: https://docs.oracle.com/javase/8/docs/api/java/io/DataOutputStream.html

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

Możesz użyć maski bitowej (1 << k) i wykonać operację AND z liczbą! 1 << k ma jeden bit w pozycji 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();
}

Działa z podpisanymi i niepodpisanymi wartościami, przy użyciu potężnej manipulacji bitami i generuje pierwsze zera po lewej stronie.

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