(Java) Specificare il numero di bit (lunghezza) durante la conversione del numero binario in stringa?
Domanda
Sto provando a memorizzare un numero come stringa binaria in un array, ma devo specificare il numero di bit per memorizzarlo.
Ad esempio, se devo memorizzare 0 con due bit, ho bisogno di una stringa "00". O 1010 con 6 bit così "001010".
Qualcuno può aiutare?
EDIT: Grazie ragazzi, dato che sono spazzatura in matematica / programmazione in generale, ho scelto la soluzione più semplice che era quella di David. Qualcosa del tipo:
binaryString.append(Integer.toBinaryString(binaryNumber));
for(int n=binaryString.length(); n<numberOfBits; n++) {
binaryString.insert(0, "0");
}
Sembra funzionare bene, quindi a meno che non sia molto inefficiente ci andrò.
Soluzione
Usa Integer.toBinaryString ()
quindi controlla la lunghezza della stringa e anteponila con tutti gli zeri di cui hai bisogno per raggiungere la lunghezza desiderata.
Altri suggerimenti
Dimentica le soluzioni fatte in casa. Utilizza invece lo standard BigInteger . Puoi specificare il numero di bit e quindi utilizzare il metodo toString (int radix) per recuperare ciò di cui hai bisogno (suppongo che tu abbia bisogno di radix = 2).
MODIFICA: Lascio il controllo bit a BigInteger. L'oggetto ridimensionerà internamente il suo buffer di bit per adattarsi alla nuova dimensione numerica. Inoltre, è possibile eseguire operazioni aritmetiche mediante questo oggetto (non è necessario implementare additivi / moltiplicatori binari, ecc.). Ecco un esempio di base:
package test;
import java.math.BigInteger;
public class TestBigInteger
{
public static void main(String[] args)
{
String value = "1010";
BigInteger bi = new BigInteger(value,2);
// Arithmetic operations
System.out.println("Output: " + bi.toString(2));
bi = bi.add(bi); // 10 + 10
System.out.println("Output: " + bi.toString(2));
bi = bi.multiply(bi); // 20 * 20
System.out.println("Output: " + bi.toString(2));
/*
* Padded to the next event number of bits
*/
System.out.println("Padded Output: " + pad(bi.toString(2), bi.bitLength() + bi.bitLength() % 2));
}
static String pad(String s, int numDigits)
{
StringBuffer sb = new StringBuffer(s);
int numZeros = numDigits - s.length();
while(numZeros-- > 0) {
sb.insert(0, "0");
}
return sb.toString();
}
}
Questo è un problema comune a casa. C'è un bel loop che puoi scrivere che calcolerà la minima potenza di 2 > = il tuo numero di destinazione n .
Poiché è una potenza di 2, il logaritmo di base 2 è il numero di bit. Ma la libreria Java math
offre solo logaritmi naturali.
math.log( n ) / math.log(2.0)
è il numero di bit.
Ancora più semplice:
String binAddr = Integer.toBinaryString(Integer.parseInt(hexAddr, 16));
String.format("%032", new BigInteger(binAddr));
L'idea qui è di analizzare temporaneamente la stringa come un numero decimale (uno che in questo modo è composto da tutti gli 1 e gli 0) e quindi utilizzare String.format ().
Nota che in pratica devi usare BigInteger, perché le stringhe binarie traboccano rapidamente Integer e Long risultando in NumberFormatExceptions se provi a usare Integer.fromString ()
o Long.fromString ()
.
Prova questo:
String binaryString = String.format("%"+Integer.toString(size)+"s",Integer.toBinaryString(19)).replace(" ","0");
dove la dimensione può essere qualsiasi numero desiderato dall'utente
Ecco una semplice soluzione per i valori int
; dovrebbe essere ovvio come estenderlo ad es. byte, ecc.
public static String bitString(int i, int len) {
len = Math.min(32, Math.max(len, 1));
char[] cs = new char[len];
for (int j = len - 1, b = 1; 0 <= j; --j, b <<= 1) {
cs[j] = ((i & b) == 0) ? '0' : '1';
}
return new String(cs);
}
Ecco l'output di una serie di casi di test di esempio:
0 1 0 0
0 -1 0 0
0 40 00000000000000000000000000000000 00000000000000000000000000000000
13 1 1 1
13 2 01 01
13 3 101 101
13 4 1101 1101
13 5 01101 01101
-13 1 1 1
-13 2 11 11
-13 3 011 011
-13 4 0011 0011
-13 5 10011 10011
-13 -1 1 1
-13 40 11111111111111111111111111110011 11111111111111111111111111110011
Naturalmente, sei tu a rendere il parametro lunghezza adeguato per rappresentare l'intero valore.
import java.util.BitSet;
public class StringifyByte {
public static void main(String[] args) {
byte myByte = (byte) 0x00;
int length = 2;
System.out.println("myByte: 0x" + String.valueOf(myByte));
System.out.println("bitString: " + stringifyByte(myByte, length));
myByte = (byte) 0x0a;
length = 6;
System.out.println("myByte: 0x" + String.valueOf(myByte));
System.out.println("bitString: " + stringifyByte(myByte, length));
}
public static String stringifyByte(byte b, int len) {
StringBuffer bitStr = new StringBuffer(len);
BitSet bits = new BitSet(len);
for (int i = 0; i < len; i++)
{
bits.set (i, (b & 1) == 1);
if (bits.get(i)) bitStr.append("1"); else bitStr.append("0");
b >>= 1;
}
return reverseIt(bitStr.toString());
}
public static String reverseIt(String source) {
int i, len = source.length();
StringBuffer dest = new StringBuffer(len);
for (i = (len - 1); i >= 0; i--)
dest.append(source.charAt(i));
return dest.toString();
}
}
Output:
myByte: 0x0
bitString: 00
myByte: 0x10
bitString: 001010
Quindi qui invece di 8 puoi scrivere la lunghezza desiderata e aggiungerà gli zeri di conseguenza. Se la lunghezza dell'intero indicato supera quella del numero indicato, non verranno aggiunti zeri
String.Format ("% 08d ", 1111);
Output: 00001111
String.format("%02d",1111);
uscita 1111