Преобразование строки (например, testing123) в бинарный формат на Java [закрыто]

Ваш код демонстрирует, как преобразовать целое число в различные системы счисления (двоичную, восьмеричную и шестнадцатеричную) и обратно в десятичное представление. Вот краткое пояснение к вашему коду:

1. Преобразование в разные системы счисления:

   • Вы используете Integer.toString(int i, int radix), чтобы получить строковое представление числа в двоичной, восьмеричной и шестнадцатеричной системах.

   String bNo = Integer.toString(no, 2);  // Двоичное представление: "101100"
   String oNo = Integer.toString(no, 8);  // Восьмеричное представление: "54"
   String hNo = Integer.toString(no, 16); // Шестнадцатеричное представление: "2C"
   

2. Альтернативные методы преобразования:

   • Вы можете использовать более специализированные методы: Integer.toBinaryString(), Integer.toOctalString() и Integer.toHexString(), которые упрощают код, так как не требуют указания системы счисления.

   String bNo1 = Integer.toBinaryString(no); // "101100"
   String oNo1 = Integer.toOctalString(no);  // "54"
   String hNo1 = Integer.toHexString(no);    // "2c"
   

3. Преобразование строк обратно в целое число:

   • Используя Integer.parseInt(String s, int radix), вы можете преобразовать строковые представления обратно в целые числа, указывая основание системы счисления.

   String sBNo = "101100";
   no = Integer.parseInt(sBNo, 2); // Получаем 44 из двоичного
   

   Аналогично для восьмеричных и шестнадцатеричных строк:

   String sONo = "54";
   no = Integer.parseInt(sONo, 8); // Получаем 44 из восьмеричного
   
   String sHNo = "2C";
   no = Integer.parseInt(sHNo, 16); // Получаем 44 из шестнадцатеричного
   

Эти примеры показывают, как легко работать с преобразованием между различными числовыми системами в Java. Если у вас есть дополнительные вопросы, не стесняйтесь задавать!

Обычный способ — использовать метод String#getBytes(), чтобы получить байты, представляющие строку, а затем преобразовать эти байты в другую форму (например, в шестнадцатеричный или двоичный формат).

Обратите внимание, что getBytes() использует кодировку по умолчанию, поэтому если вам нужно преобразовать строку в конкретную кодировку символов, следует использовать getBytes(String encoding). Но во многих случаях (особенно когда речь идет об ASCII) getBytes() вполне достаточно (к тому же этот метод не генерирует проверяемое исключение).

Для конкретного преобразования в двоичный формат вот пример:

String s = "foo";
byte[] bytes = s.getBytes();
StringBuilder binary = new StringBuilder();
for (byte b : bytes) {
    int val = b;
    for (int i = 0; i < 8; i++) {
        binary.append((val & 128) == 0 ? 0 : 1);
        val <<= 1;
    }
    binary.append(' ');
}
System.out.println("'" + s + "' to binary: " + binary);

Выполнение этого примера вернет:

'foo' to binary: 01100110 01101111 01101111 

В вашем коде происходит конвертация строки в байтовый массив с использованием кодировки UTF-8 и последующее восстановление строки из этого байтового массива. Вот упрощённый пример на Java:

private static final Charset UTF_8 = Charset.forName("UTF-8");

String text = "Hello World!";
byte[] bytes = text.getBytes(UTF_8);
System.out.println("bytes= " + Arrays.toString(bytes));
System.out.println("text again= " + new String(bytes, UTF_8));

Результат выполнения программы будет следующим:

bytes= [72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33]
text again= Hello World!

В данном коде строка "Hello World!" конвертируется в массив байтов, где каждый символ представлен своим числовым значением в кодировке UTF-8. Затем этот массив байтов обратно преобразуется в строку, что позволяет увидеть, что мы вернули исходный текст.

Вот мои решения. Их преимущества: понятный код, работает для всех символов. Наслаждайтесь.

Решение 1:

public static void main(String[] args) {
    String str = "CC%";
    String result = "";
    char[] messChar = str.toCharArray();

    for (int i = 0; i < messChar.length; i++) {
        result += Integer.toBinaryString(messChar[i]) + " ";
    }

    System.out.println(result);
}

Выводит:

1000011 1000011 100101

Решение 2:

Возможность выбора количества отображаемых битов на символ.

public static String toBinary(String str, int bits) {
    String result = "";
    String tmpStr;
    int tmpInt;
    char[] messChar = str.toCharArray();

    for (int i = 0; i < messChar.length; i++) {
        tmpStr = Integer.toBinaryString(messChar[i]);
        tmpInt = tmpStr.length();
        if (tmpInt != bits) {
            tmpInt = bits - tmpInt;
            if (tmpInt == bits) {
                result += tmpStr;
            } else if (tmpInt > 0) {
                for (int j = 0; j < tmpInt; j++) {
                    result += "0";
                }
                result += tmpStr;
            } else {
                System.err.println("аргумент 'bits' слишком мал");
            }
        } else {
            result += tmpStr;
        }
        result += " "; // разделитель
    }

    return result;
}

public static void main(String args[]) {
    System.out.println(toBinary("CC%", 8));
}

Выводит:

01000011 01000011 00100101

Ваш код выглядит вполне правильно, но давайте я объясню, что он делает, и предложу несколько улучшений.

Ваш класс Test содержит метод toBinary, который принимает строку text и возвращает строку, представляющую бинарное представление каждого символа строки, где каждое представление записано на новой строке.

Вот основной момент: вы используете Integer.toBinaryString(character) для преобразования каждого символа в его бинарное представление. Однако character — это символ, а не число, и вызов Integer.toBinaryString на символе действительно работает, потому что символ автоматически преобразуется в его целочисленный код (например, код символа 'A' равен 65, и его бинарное представление — это "1000001").

Чтобы улучшить ваш код, можно добавить один маленький момент: вместо добавления новой строки при каждом преобразовании символа, можно использовать String.join в конце для соединения всех бинарных строк вместе. Это может сделать код чуть более читаемым и эффективным. Вот переписанный вариант вашего метода:

public class Test {
    public String toBinary(String text) {
        StringBuilder sb = new StringBuilder();

        for (char character : text.toCharArray()) {
            sb.append(Integer.toBinaryString(character)).append("\n");
        }

        return sb.toString();
    }
}

Либо с использованием String.join:

public class Test {
    public String toBinary(String text) {
        return String.join("\n", 
                           text.chars()
                               .mapToObj(Integer::toBinaryString)
                               .toArray(String[]::new));
    }
}

Этот вариант кода более "современный" и использует потоковые операции, что может быть предпочтительным для более новых разработчиков Java.

Надеюсь, это поможет! Если у вас есть дополнительные вопросы, не стесняйтесь задавать!