Целое число в двоичный массив

Question

Я пытаюсь преобразовать целое число в 7-битный логический двоичный массив.Пока код не работает: если я введу, скажем, целое число 8 для преобразования, вместо 0001000 я получу 1000000, или скажу 15, я должен получить 0001111, но я получу 1111000. Массив char отличается от длины двоичного массиванеправильные позиции.

public static void main(String[] args){

    String maxAmpStr = Integer.toBinaryString(8);
    char[] arr = maxAmpStr.toCharArray();
    boolean[] binaryarray = new boolean[7];
    for (int i=0; i<maxAmpStr.length(); i++){
        if (arr[i] == '1'){             
            binaryarray[i] = true;  
        }
        else if (arr[i] == '0'){
            binaryarray[i] = false; 
        }
    }

    System.out.println(maxAmpStr);
    System.out.println(binaryarray[0]);
    System.out.println(binaryarray[1]);
    System.out.println(binaryarray[2]);
    System.out.println(binaryarray[3]);
    System.out.println(binaryarray[4]);
    System.out.println(binaryarray[5]);
    System.out.println(binaryarray[6]);
}

Любая помощь приветствуется.

Answer 1

Для этого действительно нет необходимости иметь дело со строками, просто сделайте побитовое сравнение для 7 битов, которые вас интересуют.

public static void main(String[] args) {

    int input = 15;

    boolean[] bits = new boolean[7];
    for (int i = 6; i >= 0; i--) {
        bits[i] = (input & (1 << i)) != 0;
    }

    System.out.println(input + " = " + Arrays.toString(bits));
}

Answer 2

Я бы использовал это:

private static boolean[] toBinary(int number, int base) {
    final boolean[] ret = new boolean[base];
    for (int i = 0; i < base; i++) {
        ret[base - 1 - i] = (1 << i & number) != 0;
    }
    return ret;
}

число 15 с основанием 7 даст {false, false, false, true, true, true, true} = 0001111b

число 8, основание 7 {ложь, ложь, ложь, правда, ложь, ложь, ложь} = 0001000b

Answer 3

То, что вы получаете, когда вы делаете System.out.println(maxAmpStr);, равно «1000» в случае 8. Таким образом, вы получаете только соответствующую часть, первое ожидаемое «0000» просто опущено.

Этоне красиво, но то, что вы могли бы сделать:

for (int i=0; i<maxAmpStr.length(); i++)
{
    if (arr[i] == '1')
    {
        binaryarray[i+maxAmpStr.length()-1] = true;
    }
    else if (arr[i] == '0')
    {
        binaryarray[i+maxAmpStr.length()-1] = false;
    }
}

Answer 4

Поскольку здесь никто не имеет ответа с длиной динамического массива, вот мое решение:

public static boolean[] convertToBinary(int number) {
    int binExpo = 0;
    int bin = 1;
    while(bin < number) { //calculates the needed digits
        bin = bin*2;
        binExpo++;
    }
    bin = bin/2;
    boolean[] binary = new boolean[binExpo]; //array with the right length
    binExpo--;
    while(binExpo>=0) {
        if(bin<=number) {
            binary[binExpo] = true;
            number =number -bin;
            bin = bin/2;
        }else {
            binary[binExpo] = false;
        }
        binExpo--;
    }
    return binary;
}

Answer 5

Подсказки : Подумайте о том, что происходит, когда вы получаете символьное представление, которое меньше семи символов.

В частности, подумайте о том, как строчные массивы char[] и boolean[] "вверх ";в одном элементе будет больше, чем в другом, поэтому как должны совпадать индексы?

---

Фактический ответ : В данный момент вы используете первый элемент массива символовв качестве первого элемента логического массива, который является правильным только при использовании строки из семи символов.Фактически, вы хотите, чтобы элементы last массивов совпадали (чтобы нули были заполнены спереди, а не в конце).

Одним из способов решения этой проблемы было быпоиграйтесь с индексами внутри цикла (например, определите разницу в размере и измените binaryarray[i + offset]).Но еще более простое решение - просто добавить строку с нулями после первой строки, чтобы обеспечить ровно семь символов, прежде чем преобразовать ее в массив символов.

(Дополнительные отметки: что вы делаете, когда есть большечем 7 символов в массиве, например, если кто-то передает 200 в качестве аргумента? Основываясь на обоих вышеупомянутых решениях, вы сможете легко обнаружить этот случай и обработать его конкретно.)

Answer 6

Массив char имеет столько времени, сколько необходимо, поэтому ваш логический массив может быть длиннее и размещать биты в неправильной позиции. Итак, начните сзади, и когда ваш char-массив закончится, заполните ваш логический массив нулями до первой позиции.

Answer 7

String maxAmpStr = Integer.toBinaryString(255);
    char[] arr = maxAmpStr.toCharArray();
    boolean[] binaryarray = new boolean[20];
    int pivot = binaryarray.length - arr.length;
    int j = binaryarray.length - 1;
    for (int i = arr.length - 1; i >= 0; i--) {
        if (arr[i] == '1') {
            binaryarray[j] = true;
        } else if (arr[i] == '0') {
            binaryarray[j] = false;
        }
        if (j >= pivot)
            j--;
    }

    System.out.println(maxAmpStr);
    for (int k = 0; k < binaryarray.length; k++)
        System.out.println(binaryarray[k]);
}

Answer 8

  public static boolean[] convertToBinary(int b){
    boolean[] binArray = new boolean[7];
    boolean bin;
    for(int i = 6; i >= 0; i--) {
      if (b%2 == 1) bin = true;
      else bin = false;
      binArray[i] = bin;
      b/=2;
    }
    return binArray;
  }

Answer 9

    public static String intToBinary(int num) {
    int copy = num;
    String sb = "";
    for(int i=30; i>=0; i--) {
        sb = (copy&1) + sb;
        copy = copy >>>=1;
    }
    return sb;
}

1. И число с 1
2. Добавить значение в строку
3. Повторить шаги без сдвига без знака повторите шаги 1-3 для i = 30..0

Answer 10

15.ToBinaryString будет '1111'

Вы просматриваете это от первого до последнего символа, поэтому первый «1», который является битом (3), входит в двоичный массив [0], который, как я предполагаю, должен быть битом 0.

Вы должны дополнить ToBinaryString ведущими нулями на длину 7 (8 ??) и затем перевернуть строку (или ваш цикл)

Или вы можете перестать возиться со строками и просто использовать побитовые операторы

BinaryArray [3] = (SomeInt && 2 ^ 3! = 0);

^ = оператор степени или, если нет (1 << 3), или любой другой сдвиг влево в Java. </p>