para - convertir decimal a binario java netbeans

¿Cómo obtener una representación binaria con 0 rellenos de un entero en Java?

Question

por ejemplo, para 1, 2, 128, 256 la salida puede ser (16 dígitos):

0000000000000001
0000000000000010
0000000010000000
0000000100000000

Lo intenté

String.format("%16s", Integer.toBinaryString(1));

pone espacios para el margen izquierdo:

`               1''

Cómo poner 0 s para el relleno. No pude encontrarlo en Formatter . ¿Hay alguna otra forma de hacerlo?

Gracias por adelantado.

PD: esta publicación describe cómo formatear enteros con 0-relleno izquierdo, pero no es para la representación binaria.

Answer 1

// A continuación se manejarán los tamaños adecuados

public static String binaryString(int i) {
    return String.format("%" + Integer.SIZE + "s", Integer.toBinaryString(i)).replace('' '', ''0'');
}

public static String binaryString(long i) {
    return String.format("%" + Long.SIZE + "s", Long.toBinaryString(i)).replace('' '', ''0'');
}

Answer 2

Aquí una nueva respuesta para una publicación anterior.

Para rellenar un valor binario con ceros a una longitud específica, intente esto:

Integer.toBinaryString( (1 << len) | val ).substring( 1 )

Si len = 4 y val = 1 ,

Integer.toBinaryString( (1 << len) | val )

devuelve la cadena "10001" , luego

"10001".substring( 1 )

descarta el primer personaje. Entonces obtenemos lo que queremos:

"0001"

Si val es probable que sea negativo, mejor intente:

Integer.toBinaryString( (1 << len) | (val & ((1 << len) - 1)) ).substring( 1 )

Answer 3

Creo que esta es una solución subóptima, pero podrías hacer

String.format("%16s", Integer.toBinaryString(1)).replace('' '', ''0'')

Answer 4

Escribiría mi propia clase de utilidades con el método siguiente

public class NumberFormatUtils {

public static String longToBinString(long val) {
    char[] buffer = new char[64];
    Arrays.fill(buffer, ''0'');
    for (int i = 0; i < 64; ++i) {
        long mask = 1L << i;
        if ((val & mask) == mask) {
            buffer[63 - i] = ''1'';
        }
    }
    return new String(buffer);
}

public static void main(String... args) {
    long value = 0b0000000000000000000000000000000000000000000000000000000000000101L;
    System.out.println(value);
    System.out.println(Long.toBinaryString(value));
    System.out.println(NumberFormatUtils.longToBinString(value));
}

}

Salida:

5 101 0000000000000000000000000000000000000000000000000000000000000101

El mismo enfoque podría aplicarse a cualquier tipo integral. Presta atención al tipo de máscara

long mask = 1L << i;

Answer 5

Estaba probando todo tipo de llamadas a métodos que no había usado antes para hacer que esto funcione, trabajaron con un éxito moderado, hasta que pensé en algo que es tan simple que podría funcionar, y así fue.

Estoy seguro de que ya se pensó en eso, pero no estoy seguro de si sirve para cadenas largas de códigos binarios, pero funciona bien para cadenas de 16 bits. ¡¡Espero eso ayude!! (Tenga en cuenta que se mejora la segunda parte del código)

String binString = Integer.toBinaryString(256);
  while (binString.length() < 16) {    //pad with 16 0''s
        binString = "0" + binString;
  }

Gracias a Will por ayudar a mejorar esta respuesta para que funcione sin problemas. Esto tal vez un poco torpe pero funciona, por favor mejora y comenta si puedes ....

binString = Integer.toBinaryString(256);
int length = 16 - binString.length();
char[] padArray = new char[length];
Arrays.fill(padArray, ''0'');
String padString = new String(padArray);
binString = padString + binString;

Answer 6

Este es un viejo truco, crea una cadena con 16 0 y luego agrega la cadena binaria recortada que obtuviste de String.format ("% s", Integer.toBinaryString (1)) y utiliza los 16 caracteres de la derecha, cortando cualquier línea principal 0''s. Mejor aún, realice una función que le permita especificar cuánto tiempo desea una cadena binaria. Por supuesto, hay probablemente otras tantas maneras de lograr esto, incluidas las bibliotecas, pero estoy agregando esta publicación para ayudar a un amigo :)

public class BinaryPrinter {

    public static void main(String[] args) {
        System.out.format("%d in binary is %s/n", 1, binaryString(1, 4));
        System.out.format("%d in binary is %s/n", 128, binaryString(128, 8));
        System.out.format("%d in binary is %s/n", 256, binaryString(256, 16));
    }

    public static String binaryString( final int number, final int binaryDigits ) {
        final String pattern = String.format( "%%0%dd", binaryDigits );
        final String padding = String.format( pattern, 0 );
        final String response = String.format( "%s%s", padding, Integer.toBinaryString(number) );

        System.out.format( "/npattern = ''%s''/npadding = ''%s''/nresponse = ''%s''/n/n", pattern, padding, response );

        return response.substring( response.length() - binaryDigits );
    }
}

Answer 7

Este método convierte un int en una cadena, length = bits. O rellenado con 0 o con los bits más significativos truncados.

static String toBitString( int x, int bits ){
    String bitString = Integer.toBinaryString(x);
    int size = bitString.length();
    StringBuilder sb = new StringBuilder( bits );
    if( bits > size ){
        for( int i=0; i<bits-size; i++ )
            sb.append(''0'');
        sb.append( bitString );
    }else
        sb = sb.append( bitString.substring(size-bits, size) );

    return sb.toString();
}

Answer 8

No hay una conversión binaria integrada en java.util.Formatter, le aconsejo que use String.replace para reemplazar el carácter de espacio con ceros, como en:

String.format("%16s", Integer.toBinaryString(1)).replace(" ", "0")

O implemente su propia lógica para convertir enteros en representación binaria con relleno izquierdo añadido en algún lugar a lo largo de las líneas dadas en this punto. O si realmente necesita pasar números para formatear, puede convertir su representación binaria en BigInteger y luego formatear eso con ceros a la izquierda, pero esto es muy costoso en tiempo de ejecución, como en:

String.format("%016d", new BigInteger(Integer.toBinaryString(1)))

Answer 9

No sé la solución "correcta", pero puedo sugerirle un parche rápido.

String.format("%16s", Integer.toBinaryString(1)).replace(" ", "0");

Lo acabo de probar y vi que funciona bien.

Answer 10

Puede usar lib https://github.com/kssource/BitSequence . Acepta un número y devuelve una cadena bynary, acolchada y / o agrupada.

String s = new BitSequence(2, 16).toBynaryString(ALIGN.RIGHT, GROUP.CONTINOUSLY));  
return  
0000000000000010  

another examples:

[10, -20, 30]->00001010 11101100 00011110
i=-10->00000000000000000000000000001010
bi=10->1010
sh=10->00 0000 0000 1010
l=10->00000001 010
by=-10->1010
i=-10->bc->11111111 11111111 11111111 11110110

Answer 11

Puedes usar Apache Commons StringUtils . Ofrece métodos para cadenas de relleno:

StringUtils.leftPad(Integer.toBinaryString(1), 16, ''0'');

Answer 12

Una solución ingenua que funcionaría

String temp = Integer.toBinaryString(5);
while (temp.length() < Integer.SIZE) temp = "0"+temp; //pad leading zeros
temp = temp.substring(Integer.SIZE - Short.SIZE); //remove excess

Otro método sería

String temp = Integer.toBinaryString((m | 0x80000000));
temp = temp.substring(Integer.SIZE - Short.SIZE);

Esto producirá una cadena de 16 bits del entero 5

Answer 13

Una versión más simple de la idea de user3608934 "Este es un viejo truco, crea una cadena con 16 0 y luego agrega la cadena binaria recortada que obtuviste":

private String toBinaryString32(int i) {
    String binaryWithOutLeading0 = Integer.toBinaryString(i);
    return "00000000000000000000000000000000"
            .substring(binaryWithOutLeading0.length())
            + binaryWithOutLeading0;
}

Answer 14

tratar...

String.format("%016d/n", Integer.parseInt(Integer.toBinaryString(256)));

No creo que esta sea la forma "correcta" de hacer esto ... pero funciona :)

Answer 15

for(int i=0;i<n;i++)
{
  for(int j=str[i].length();j<4;j++)
  str[i]="0".concat(str[i]);
}

str[i].length() es la longitud del número, por ejemplo, 2 en binario es 01, que es la longitud 2, cambia 4 a la longitud máxima deseada de número. Esto se puede optimizar a O (n). usando continuar.