Java에서 이진 형식으로 정수 인쇄

Java에서 이진 형식으로 정수 인쇄

번호가 있는데 2진수로 출력하고 싶어.알고리즘을 써서 하고 싶지 않다.

자바에는 그것을 위한 내장 기능이 있는가?

"빌트인(built-in)"을 의미하는 경우:

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

정수 설명서를 참조하십시오.

(Long비슷한 방법을 가지고 있다.BigIntegerradix를 지정할 수 있는 인스턴스(instance) 방법을 가지고 있다.)

이진 또는 다른 형식에만 의존할 필요는 없음...프로그램에서 원하는 형식을 인쇄할 수 있는 유연한 내장 기능. 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

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

나는 물건들을 잘 출력해서 n비트마다 비트를 분리할 수 있는 무언가가 필요했다.즉 선행 0을 표시하고 다음과 같은 것을 나타낸다.

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

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

구식:

    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 01 02 13 14 15 06 07 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));
    }
}

OR

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 0000 000000 0000 0001 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 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.
}

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

이 질문에 대한 좋은 답변이 이미 여기에 게시되어 있다.그러나, 이것이 내가 스스로 시도해 본 방법이다(그리고 가장 쉬운 논리 기반 → 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

왼쪽 패딩된 0으로 지정된 int x의 이진 표현:

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

비트 마스크(1< k)를 사용하고 번호로 AND 조작을 할 수 있다! 1<< k는 1비트 위치!

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

그 문제는 자바(그리고 아마도 다른 언어에서도) 까다롭다.

정수(Instant)는 32비트 부호화된 데이터 유형이지만, 정수(Instant.toBinaryString())는 정수 인수의 문자열 표현을 base 2에서 부호 없는 정수로 반환한다.

따라서 Integr.parseInt(Integer.toBinaryString(X),2)는 예외(서명된 대 서명되지 않은)를 생성할 수 있다.

안전한 방법은 Integr.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"

작동 방식: 루프가 a-숫자를 오른쪽으로 이동하는 동안(마지막 비트를 2대-마지막으로 대체하는 등) 마지막 비트 값을 얻어 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

    }

다음 방법으로 시도하십시오.

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

소수점 숫자를 입력으로 입력하십시오.그 후에 우리는 주어진 입력을 이진수로 변환하기 위해 modulo와 division과 같은 작업을 한다.다음은 정수 값을 이진수로 변환하는 Java 프로그램의 소스 코드와 그의 십진수에 대한 이 이진수의 비트 수입니다.자바 프로그램은 성공적으로 컴파일되어 윈도우 시스템에서 실행된다.프로그램 출력도 아래와 같다.

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

정수.toString(값, numbersystem) --- 사용할 구문 및 값 전달

정수.toString(100,8) // 144 --octal 인쇄

정수.toString(100,2) // 1100100 --binary 인쇄

정수.toString(100,16) //인쇄 64 --Hex

하면 내가 할 수 .의 출력을 포맷할 수 있다.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();
}

에 대한 결과toBinaryString(0xABFABF, 8)이다"10101011 11111010 10111111"
그리고 당분간은toBinaryString(0xABFABF, 4)이다"1010 1011 1111 1010 1011 1111"

강력한 비트 조작을 사용하는 서명 값과 서명되지 않은 값으로 작동하며 왼쪽에서 첫 번째 영점을 생성한다.

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

참조URL: https://stackoverflow.com/questions/5263187/print-an-integer-in-binary-format-in-java