Java'da bir tamsayının 0-dolgulu ikili gösterimi nasıl elde edilir?

örneğin, 1, 2, 128, 256çıktı (16 basamaklı) olabilir:

0000000000000001
0000000000000010
0000000010000000
0000000100000000

denedim

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

sol dolgu için boşluklar koyar:

`               1'

0Dolgu için s nasıl eklenir? Formatter'da bulamadım . Bunu yapmanın başka bir yolu var mı?

Not: Bu gönderi , tamsayıların sol 0-dolguyla nasıl biçimlendirileceğini açıklar, ancak bu ikili gösterim için değildir.

Bunun yetersiz bir çözüm olduğunu düşünüyorum, ancak

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

Java.util.Formatter'da yerleşik ikili dönüştürme yoktur, aşağıdaki gibi boşluk karakterini sıfırlarla değiştirmek için String.replace kullanmanızı tavsiye ederim:

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

Veya verilen çizgisinde eklenen sol dolgular yere ile ikilik gösterime dönüştürme tamsayılar için kendi mantığı uygulamak bu So. Veya gerçekten sayıları biçimlendirmek için iletmeniz gerekiyorsa, ikili temsilinizi BigInteger'a dönüştürebilir ve ardından bunu önde gelen sıfırlarla biçimlendirebilirsiniz, ancak bu, aşağıdaki gibi çalışma zamanında çok maliyetlidir:

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

Apache Commons StringUtils'i kullanabilirsiniz . Dizeleri doldurmak için yöntemler sunar:

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

Bu işi yapmak için daha önce gerçekten kullanmadığım her türlü yöntem çağrısını deniyordum, orta derecede başarıyla çalıştılar, çok basit bir şey düşünene kadar işe yarayabilirdi ve işe yaradı!

Eminim daha önce düşünülmüştür, uzun ikili kod dizileri için iyi olup olmadığından emin değilim, ancak 16Bit dizgiler için iyi çalışıyor. Umarım yardımcı olur!! (İkinci kod parçasının geliştirildiğine dikkat edin)

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

Will'e, bu cevabın bir döngü ile çalışmasını sağlamak için iyileştirilmesine yardımcı olduğu için teşekkürler. Bu biraz sakar olabilir ama işe yarıyor, lütfen iyileştirin ve eğer yapabiliyorsanız yorum yapın ....

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;

İşte eski bir gönderi için yeni bir cevap.

İkili değeri belirli bir uzunluğa sıfırlarla doldurmak için şunu deneyin:

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

Eğer len = 4ve val = 1,

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

dizeyi döndürür "10001", sonra

"10001".substring( 1 )

ilk karakteri atıyor. Böylece istediğimizi elde ederiz:

"0001"

Eğer valnegatif olması muhtemeldir yerine deneyin:

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

User3608934'ün "Bu eski bir numara, 16 0'lık bir dize oluşturun ve sonra sahip olduğunuz kırpılmış ikili dizeyi ekleyin" fikrinin daha basit bir versiyonu:

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

"Doğru" çözümü bilmiyorum ama size hızlı bir yama önerebilirim.

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

Sadece denedim ve iyi çalıştığını gördüm.

Deneyin...

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

Bunu yapmanın "doğru" yolu olduğunu sanmıyorum ... ama işe yarıyor :)

İşe yarayan saf bir çözüm

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

Diğer bir yöntem de

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

Bu, 5 tamsayısının 16 bitlik bir dizisini üretecektir.

Java 11'den başlayarak, tekrarlama (...) yöntemini kullanabilirsiniz:

"0".repeat(Integer.numberOfLeadingZeros(i) - 16) + Integer.toBinaryString(i)

Veya herhangi bir tamsayının 32 bit gösterimine ihtiyacınız varsa:

"0".repeat(Integer.numberOfLeadingZeros(i != 0 ? i : 1)) + Integer.toBinaryString(i)

Bu eski bir numaradır, 16 0'lık bir dize oluşturun ve ardından String.format ("% s", Integer.toBinaryString (1)) 'den aldığınız kırpılmış ikili dizeyi ekleyin ve en sağdaki 16 karakteri kullanarak baştaki herhangi bir numarayı azaltın 0 kullanıcısının. Daha da iyisi, bir ikili dizenin ne kadar uzun olmasını istediğinizi belirtmenize izin veren bir işlev yapın. Tabii ki bunu başarmanın muhtemelen sayısız başka yolu var, kütüphaneler de dahil, ancak bu yazıyı bir arkadaşıma yardımcı olmak için ekliyorum :)

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

Aşağıdaki yöntemle kendi kullanım sınıfımı yazardım

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

}

Çıktı:

5
101
0000000000000000000000000000000000000000000000000000000000000101

Aynı yaklaşım herhangi bir integral tipine uygulanabilir. Maske tipine dikkat edin

long mask = 1L << i;

Bu yöntem, bir int'i bir String, length = bit'e dönüştürür. Ya 0'larla doldurulur ya da en önemli bitler kesilir.

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

Lib https://github.com/kssource/BitSequence kullanabilirsiniz . Bir sayıyı kabul eder ve tek dizeli, doldurulmuş ve / veya gruplanmış olarak döndürür.

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

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()ikili sayıdaki 2 sayısının uzunluğu 01'dir, uzunluk 2 sayısı 4'ü istenen maksimum sayı uzunluğuna değiştirir. Bu, O (n) olarak optimize edilebilir. Continue kullanarak.

// Aşağıda uygun boyutlar ele alınacaktır

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

import java.util.Scanner;
public class Q3{
  public static void main(String[] args) {
    Scanner scn=new Scanner(System.in);
    System.out.println("Enter a number:");
    int num=scn.nextInt();
    int numB=Integer.parseInt(Integer.toBinaryString(num));
    String strB=String.format("%08d",numB);//makes a 8 character code
    if(num>=1 && num<=255){
     System.out.println(strB);
    }else{
        System.out.println("Number should be in range between 1 and 255");
    }
  }
}