(Java) Especifique o número de bits (comprimento) ao converter número binário em seqüência?
Pergunta
Eu estou tentando armazenar um número como uma string binária em uma matriz, mas eu preciso especificar quantos bits para armazená-lo como.
Por exemplo, se eu preciso para armazenar 0 com dois bits eu preciso de uma string "00". Ou 1.010 com 6 bits por isso "001010".
alguém pode ajudar?
EDIT: Obrigado rapazes, como eu sou lixo em matemática / programação em geral eu tenho ido com a solução mais simples que era Davi. Algo como:
binaryString.append(Integer.toBinaryString(binaryNumber));
for(int n=binaryString.length(); n<numberOfBits; n++) {
binaryString.insert(0, "0");
}
Parece funcionar bem, por isso, a menos que seja muito ineficiente eu vou com ele.
Solução
Use Integer.toBinaryString()
em seguida, verificar o comprimento da corda e preceder-lo com tantos zeros que você precisa fazer o seu comprimento desejado.
Outras dicas
Esqueça soluções caseiras. Use padrão BigInteger . Você pode especificar o número de bits e, em seguida, usar (int radix) Método toString para recuperar o que você precisa (I supor que você precisa base = 2).
EDIT: eu deixaria de controle pouco para BigInteger. O objeto será redimensionada internamente seu buffer pouco para se ajustar à nova dimensão número. Além disso operações aritméticas podem ser realizadas por meio deste objeto (você não tem que implementar binários somadores / multiplicadores etc.). Aqui está um exemplo básico:
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();
}
}
Este é um problema lição de casa comum. Há um laço legal que você pode escrever que irá calcular a menor potência de 2> = seu número de destino n .
Uma vez que é uma potência de 2, o logaritmo de base 2 é o número de bits. Mas a biblioteca math
Java só oferece logaritmo natural.
math.log( n ) / math.log(2.0)
é o número de bits.
Ainda mais simples:
String binAddr = Integer.toBinaryString(Integer.parseInt(hexAddr, 16));
String.format("%032", new BigInteger(binAddr));
A idéia aqui é para analisar a volta corda como um número decimal temporariamente (que só acontece a consistem em todos os 1 e 0) e, em seguida, usar String.format ().
Note que você basicamente tem que usar BigInteger, porque cadeias binárias rapidamente estouro Integer e Long resultando em NumberFormatExceptions se você tentar usar Integer.fromString()
ou Long.fromString()
.
Tente isto:
String binaryString = String.format("%"+Integer.toString(size)+"s",Integer.toBinaryString(19)).replace(" ","0");
onde o tamanho pode ser qualquer número que o usuário deseja
Aqui está uma solução simples para valores int
; deveria ser óbvio como estendê-lo para, por exemplo, byte, etc.
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);
}
Aqui está a saída de um conjunto de casos de teste de amostra:
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
Claro, você está no seu próprio para tornar o comprimento parâmetro adequado para representar o valor inteiro.
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
Então, aqui em vez de 8 você pode escrever seu comprimento desejado e vai acrescentar zeros em conformidade. Se o comprimento do seu inteiro mencionado excede o do número mencionado, então não vai Acrescente qualquer zeros
String.format("%08d",1111);
Saída: 00001111
String.format("%02d",1111);
saída: 1111