Есть ли способ достичь транслитерации символов между кодировками в java? что-то похожее на команду unix (или аналогичную функцию php):
iconv -f UTF-8 -t ASCII//TRANSLIT < some_doc.txt > new_doc.txt
предпочтительно работает со строками, не имея ничего общего с файлами
Я знаю, что вы можете изменять кодировки с помощью конструктора String, но это не обрабатывает транслитерацию символов, которые не находятся в полученной кодировке.
Я не знаю о каких-либо библиотеках, которые делают именно то, что нужно сделать iconv (что не очень хорошо определено). Однако вы можете использовать "normalization" в Java, чтобы делать такие вещи, как удаление акцентов с символов. Этот процесс хорошо определен стандартами Unicode.
Я думаю, что NFKD (декомпозиция совместимости), за которой следует фильтрация символов, отличных от ASCII, может приблизиться к тому, что вы хотите. Очевидно, что это процесс с потерями; вы никогда не сможете восстановить всю информацию, которая была в исходной строке, поэтому будьте осторожны.
/* Decompose original "accented" string to basic characters. */
String decomposed = Normalizer.normalize(accented, Normalizer.Form.NFKD);
/* Build a new String with only ASCII characters. */
StringBuilder buf = new StringBuilder();
for (int idx = 0; idx < decomposed.length(); ++idx) {
char ch = decomposed.charAt(idx);
if (ch < 128)
buf.append(ch);
}
String filtered = buf.toString();
С используемой здесь фильтрацией вы можете сделать некоторые строки нечитаемыми. Например, строка китайских символов будет полностью отфильтрована, потому что ни одно из них не имеет ASCII-представления (это больше похоже на iconv //IGNORE).
В целом, было бы безопаснее создать собственную таблицу поиска допустимых замен символов или, по крайней мере, объединить символы (акценты и вещи), которые можно безопасно разбить. Лучшее решение зависит от диапазона входных символов, которые вы ожидаете обработать.
Начнем с небольшой вариации ответа Эриксона и постройте на нем больше //TRANSLIT функций:
Stringpublic class Translit {
private static final Charset US_ASCII = Charset.forName("US-ASCII");
private static String toAscii(final String input) {
final CharsetEncoder charsetEncoder = US_ASCII.newEncoder();
final char[] decomposed = Normalizer.normalize(input, Normalizer.Form.NFKD).toCharArray();
final StringBuilder sb = new StringBuilder(decomposed.length);
for (int i = 0; i < decomposed.length; ) {
final int codePoint = Character.codePointAt(decomposed, i);
final int charCount = Character.charCount(codePoint);
if(charsetEncoder.canEncode(CharBuffer.wrap(decomposed, i, charCount))) {
sb.append(decomposed, i, charCount);
}
i += charCount;
}
return sb.toString();
}
public static void main(String[] args) {
final String a = "Michèleäöüß";
System.out.println(a + " => " + toAscii(a));
System.out.println(a.toUpperCase() + " => " + toAscii(a.toUpperCase()));
}
}
Хотя это должно вести себя одинаково для US-ASCII, это решение легче принять для разных целевых кодировок. (Так как символы сначала разложены, это не обязательно дает лучшие результаты для других кодировок)
Функция безопасна для дополнительных кодовых точек (что является избыточным избытком ASCII в качестве цели, но может уменьшить головные боли, если выбрана другая целевая кодировка).
Также обратите внимание, что возвращается регулярная строка Java-String; если вам нужен ASCII- byte[], вам все равно нужно его преобразовать (но, как мы убедились, нет обидных символов...).
И так вы можете расширить его до большего количества наборов символов:
String, закодированный в поставляемом Charsetimport java.nio.CharBuffer;
import java.nio.charset.Charset;
import java.nio.charset.CharsetEncoder;
import java.text.Normalizer;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
/**
* Created for http://stackoverflow.com/a/22841035/1266906
*/
public class Translit {
public static final Charset US_ASCII = Charset.forName("US-ASCII");
public static final Charset ISO_8859_1 = Charset.forName("ISO-8859-1");
public static final Charset UTF_8 = Charset.forName("UTF-8");
public static final HashMap<Integer, String> REPLACEMENTS = new ReplacementBuilder().put('„', '"')
.put('"', '"')
.put('"', '"')
.put('″', '"')
.put('€', "EUR")
.put('ß', "ss")
.put('•', '*')
.getMap();
private static String toCharset(final String input, Charset charset) {
return toCharset(input, charset, Collections.<Integer, String>emptyMap());
}
private static String toCharset(final String input,
Charset charset,
Map<? super Integer, ? extends String> replacements) {
final CharsetEncoder charsetEncoder = charset.newEncoder();
return toCharset(input, charsetEncoder, replacements);
}
private static String toCharset(String input,
CharsetEncoder charsetEncoder,
Map<? super Integer, ? extends String> replacements) {
char[] data = input.toCharArray();
final StringBuilder sb = new StringBuilder(data.length);
for (int i = 0; i < data.length; ) {
final int codePoint = Character.codePointAt(data, i);
final int charCount = Character.charCount(codePoint);
CharBuffer charBuffer = CharBuffer.wrap(data, i, charCount);
if (charsetEncoder.canEncode(charBuffer)) {
sb.append(data, i, charCount);
} else if (replacements.containsKey(codePoint)) {
sb.append(toCharset(replacements.get(codePoint), charsetEncoder, replacements));
} else {
// Only perform NFKD Normalization after ensuring the original character is invalid as this is a irreversible process
final char[] decomposed = Normalizer.normalize(charBuffer, Normalizer.Form.NFKD).toCharArray();
for (int j = 0; j < decomposed.length; ) {
int decomposedCodePoint = Character.codePointAt(decomposed, j);
int decomposedCharCount = Character.charCount(decomposedCodePoint);
if (charsetEncoder.canEncode(CharBuffer.wrap(decomposed, j, decomposedCharCount))) {
sb.append(decomposed, j, decomposedCharCount);
} else if (replacements.containsKey(decomposedCodePoint)) {
sb.append(toCharset(replacements.get(decomposedCodePoint), charsetEncoder, replacements));
}
j += decomposedCharCount;
}
}
i += charCount;
}
return sb.toString();
}
public static void main(String[] args) {
final String a = "Michèleäöü߀„""″•";
System.out.println(a + " => " + toCharset(a, US_ASCII));
System.out.println(a + " => " + toCharset(a, ISO_8859_1));
System.out.println(a + " => " + toCharset(a, UTF_8));
System.out.println(a + " => " + toCharset(a, US_ASCII, REPLACEMENTS));
System.out.println(a + " => " + toCharset(a, ISO_8859_1, REPLACEMENTS));
System.out.println(a + " => " + toCharset(a, UTF_8, REPLACEMENTS));
}
public static class MapBuilder<K, V> {
private final HashMap<K, V> map;
public MapBuilder() {
map = new HashMap<K, V>();
}
public MapBuilder<K, V> put(K key, V value) {
map.put(key, value);
return this;
}
public HashMap<K, V> getMap() {
return map;
}
}
public static class ReplacementBuilder extends MapBuilder<Integer, String> {
public ReplacementBuilder() {
super();
}
@Override
public ReplacementBuilder put(Integer input, String replacement) {
super.put(input, replacement);
return this;
}
public ReplacementBuilder put(Integer input, char replacement) {
return this.put(input, String.valueOf(replacement));
}
public ReplacementBuilder put(char input, String replacement) {
return this.put((int) input, replacement);
}
public ReplacementBuilder put(char input, char replacement) {
return this.put((int) input, String.valueOf(replacement));
}
}
}
Я бы настоятельно рекомендовал создать обширную таблицу замены, поскольку простой пример уже показывает, как вы могли бы потерять желаемую информацию, например €. Для ASCII эта реализация, конечно, немного медленнее, поскольку декомпозиция выполняется только по требованию, а теперь StringBuilder может расти, чтобы сохранить замены.
GNU iconv использует замены, перечисленные в translit.def, чтобы выполнить //TRANSLIT -конверсию, и вы можете использовать такой метод, если это вы хотите использовать его в качестве замены-карты:
//TRANSLIT -рементыprivate static Map<Integer, String> readReplacements() {
HashMap<Integer, String> map = new HashMap<>();
InputStream stream = Translit.class.getResourceAsStream("/translit.def");
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(stream, UTF_8));
Pattern pattern = Pattern.compile("^([0-9A-Fa-f]+)\t(.?[^\t]*)\t#(.*)$");
try {
String line;
while ((line = bufferedReader.readLine()) != null) {
if (line.charAt(0) != '#') {
Matcher matcher = pattern.matcher(line);
if (matcher.find()) {
map.put(Integer.valueOf(matcher.group(1), 16), matcher.group(2));
}
}
}
} catch (IOException e) {
e.printStackTrace();
}
return map;
}
Одним из решений является выполнение execute iconv как внешнего процесса. Это, безусловно, оскорбит пуристов. Это зависит от наличия иконки в системе, но она работает и делает именно то, что вы хотите:
public static String utfToAscii(String input) throws IOException {
Process p = Runtime.getRuntime().exec("iconv -f UTF-8 -t ASCII//TRANSLIT");
BufferedWriter bwo = new BufferedWriter(new OutputStreamWriter(p.getOutputStream()));
BufferedReader bri = new BufferedReader(new InputStreamReader(p.getInputStream()));
bwo.write(input,0,input.length());
bwo.flush();
bwo.close();
String line = null;
StringBuilder stringBuilder = new StringBuilder();
String ls = System.getProperty("line.separator");
while( ( line = bri.readLine() ) != null ) {
stringBuilder.append( line );
stringBuilder.append( ls );
}
bri.close();
try {
p.waitFor();
} catch ( InterruptedException e ) {
}
return stringBuilder.toString();
}