Преобразование UTF-16 в ASCII в Java

Как насчет этого:

String input = ... // my UTF-16 string
StringBuilder sb = new StringBuilder(input.length());
for (int i = 0; i < input.length(); i++) {
    char ch = input.charAt(i);
    if (ch <= 0xFF) {
        sb.append(ch);
    }
}

byte[] ascii = sb.toString().getBytes("ISO-8859-1"); // aka LATIN-1

Вероятно, это не самый эффективный способ преобразования больших строк, поскольку мы копируем символы дважды. Тем не менее, у него есть преимущество в том, что он прямолинеен.

Кстати, строго говоря, нет такого набора символов, как 8-битный ASCII. ASCII — это 7-битный набор символов. LATIN-1 ближе всего к «8-битному набору символов ASCII» (и блок 0 Unicode эквивалентен LATIN-1), поэтому я предполагаю, что вы имеете в виду именно это.

РЕДАКТИРОВАТЬ: в свете обновления вопроса решение еще проще:

String input = ... // my UTF-16 string
byte[] ascii = new byte[input.length()];
for (int i = 0; i < input.length(); i++) {
    ascii[i] = (byte) input.charAt(i);
}

Это решение является более эффективным. Поскольку теперь мы знаем, сколько байтов ожидать, мы можем предварительно выделить массив байтов и скопировать (усеченные) символы без использования StringBuilder в качестве промежуточного буфера.

Однако я не уверен, что такое обращение с неверными данными разумно.

РЕДАКТИРОВАТЬ 2: с этим есть еще одна неясная ошибка. Unicode фактически определяет кодовые точки (символы) как «примерно 21-битные» значения ... от 0x000000 до 0x10FFFF ... и использует суррогаты для представления кодов> 0x00FFFF. Другими словами, кодовая точка Unicode> 0x00FFFF фактически представлена ​​​​в UTF-16 как два «символа». Ни мой ответ, ни какой-либо другой не учитывают этот (по общему признанию эзотерический) момент. На самом деле, работать с кодовыми точками > 0x00FFFF в Java довольно сложно. Это связано с тем, что 'char' является 16-битным типом, а String определяется в терминах 'char'.

РЕДАКТИРОВАТЬ 3: возможно, более разумным решением для работы с неожиданными символами, которые не преобразуются в ASCII, является замена их стандартным символом замены:

String input = ... // my UTF-16 string
byte[] ascii = new byte[input.length()];
for (int i = 0; i < input.length(); i++) {
    char ch = input.charAt(i);
    ascii[i] = (ch <= 0xFF) ? (byte) ch : (byte) '?';
}

Вы можете использовать java.nio для простого решения:

// first encode the utf-16 string as a ByteBuffer
ByteBuffer bb = Charset.forName("utf-16").encode(CharBuffer.wrap(utf16str));
// then decode those bytes as US-ASCII
CharBuffer ascii = Charset.forName("US-ASCII").decode(bb);

Java внутренне представляет строки в UTF-16. Если вы начинаете с объекта String, вы можете кодировать с помощью String.getBytes(Charset c), где вы можете указать US-ASCII (который может отображать кодовые точки 0x00-0x7f) или ISO-8859-1 ( который может отображать кодовые точки 0x00-0xff и может быть тем, что вы подразумеваете под «8-битным ASCII»).

Что касается добавления "плохих данных"... Строки ASCII или ISO-8859-1 просто не могут представлять значения за пределами определенного диапазона. Я считаю, что getBytes просто отбросит символы, которые он не может представить в целевом наборе символов.

Поскольку это упражнение, похоже, вам нужно реализовать это вручную. Вы можете думать о кодировке (например, UTF-16 или ASCII) как о таблице поиска, которая сопоставляет последовательность байтов с логическим символом (кодовой точкой).

Java использует строки UTF-16, что означает, что любой код может быть представлен одной или двумя переменными char. Хотите ли вы обрабатывать суррогатные пары two-char, зависит от того, насколько вероятно, по вашему мнению, ваше приложение столкнется с ними (см. класс символов для их обнаружения). ASCII использует только первые 7 бит октета (байта), поэтому допустимый диапазон значений от 0 до 127. UTF-16 использует идентичные значения для этого диапазона (они просто шире). Это можно подтвердить с помощью этого кода:

Charset ascii = Charset.forName("US-ASCII");
byte[] buffer = new byte[1];
char[] cbuf = new char[1];
for (int i = 0; i <= 127; i++) {
  buffer[0] = (byte) i;
  cbuf[0] = (char) i;
  String decoded = new String(buffer, ascii);
  String utf16String = new String(cbuf);
  if (!utf16String.equals(decoded)) {
    throw new IllegalStateException();
  }
  System.out.print(utf16String);
}
System.out.println("\nOK");

Поэтому вы можете преобразовать UTF-16 в ASCII, приведя char к byte.

Подробнее о кодировке символов Java можно прочитать здесь< /а>.

Просто чтобы оптимизировать принятый ответ и не платить штраф, если строка уже содержит все символы ascii, вот оптимизированная версия. Спасибо @stephen-c

public static String toAscii(String input) {
  final int length = input.length();
  int ignoredChars = 0;
  byte[] ascii = null;
  for (int i = 0; i < length; i++) {
    char ch = input.charAt(i);
    if (ch > 0xFF) {
      //-- ignore this non-ascii character
      ignoredChars++;
      if (ascii == null) {
        //-- first non-ascii character. Create a new ascii array with all ascii characters
        ascii = new byte[input.length() - 1];  //-- we know, the length will be at less by at least 1
        for (int j = 0; j < i-1; j++) {
          ascii[j] = (byte) input.charAt(j);
        }
      }
    } else if (ascii != null) {
      ascii[i - ignoredChars] = (byte) ch;
    }
  }
  //-- (ignoredChars == 0) is the same as (ascii == null) i.e. no non-ascii characters found
  return ignoredChars == 0 ? input : new String(Arrays.copyOf(ascii, length - ignoredChars));
}