Odpowiedzi:
Zakładając, że masz na myśli „wbudowany”:
int x = 100;
System.out.println(Integer.toBinaryString(x));
Zobacz dokumentację liczb całkowitych .
( Long
ma podobną metodę, BigInteger
ma 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
toBinaryString
używa wyjścia uzupełnienia do dwóch, toString
ukrywa liczbę określoną bazę i umieszcza przed nią znak ujemny, więctoString(-8, 2) == "-1000"
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));
}
result.replace(result.length() - 1, result.length(), "");
jest to wymagane? Jak mijamy, int
który jest już 32-bitowy. Co zastępujemy w drugiej ostatniej linii?
String
klasy, trim
aby osiągnąć ten sam efekt.
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));
System.out.println
i &
są wbudowane;)
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
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();
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();
}