Есть ли лучший способ избавиться от акцентов и сделать эти буквы регулярными, не используя метод String.replaceAll() и заменяя буквы один за другим?
Пример:
Вход: orčpžsíáýd
Выход: orcpzsiayd
Не нужно включать все буквы с акцентами, такими как русский алфавит или китайский.
Используйте java.text.Normalizer, чтобы справиться с этим за вас.
string = Normalizer.normalize(string, Normalizer.Form.NFD);
// or Normalizer.Form.NFKD for a more "compatable" deconstruction
Это отделит все знаки ударения от персонажей. Затем вам просто нужно сравнить каждый символ с буквой и выбросить те, которые не являются.
string = string.replaceAll("[^\\p{ASCII}]", "");
Если ваш текст в Unicode, вы должны использовать это вместо:
string = string.replaceAll("\\p{M}", "");
Для юникода \\P{M} соответствует базовому глифу, а \\p{M} (в нижнем регистре) соответствует каждому акценту.
Спасибо GarretWilson за указатель и регулярному выражению .info за великолепное руководство по юникоду.
Начиная с 2011 года вы можете использовать Apache Commons StringUtils.stripAccents (вход) (начиная с версии 3.0):
String input = StringUtils.stripAccents("Tĥïŝ ĩš â fůňķŷ Šťŕĭńġ");
System.out.println(input);
// Prints "This is a funky String"
Примечание:
Принятый ответ (Эрик Робертсон) не работает для Ø или Ł. Apache Commons 3.5 не работает и для Ø, но для Ł. Прочитав статью в Википедии для Ø, я не уверен, что ее следует заменить на "О": это отдельное письмо на норвежском и датском языках в алфавитном порядке после "z". Это хороший пример ограничений подхода "раздевания".
Решение @virgo47 очень быстрое, но приблизительное. В принятом ответе используется Normalizer и регулярное выражение. Я задавался вопросом, какая часть времени была занята Normalizer в сравнении с регулярным выражением, так как удаление всех символов без ASCII может выполняться без регулярного выражения:
import java.text.Normalizer;
public class Strip {
public static String flattenToAscii(String string) {
StringBuilder sb = new StringBuilder(string.length());
string = Normalizer.normalize(string, Normalizer.Form.NFD);
for (char c : string.toCharArray()) {
if (c <= '\u007F') sb.append(c);
}
return sb.toString();
}
}
Небольшие дополнительные ускорения можно получить, записав в char [] и не вызывая toCharArray(), хотя я не уверен, что уменьшение ясности кода заслуживает этого:
public static String flattenToAscii(String string) {
char[] out = new char[string.length()];
string = Normalizer.normalize(string, Normalizer.Form.NFD);
int j = 0;
for (int i = 0, n = string.length(); i < n; ++i) {
char c = string.charAt(i);
if (c <= '\u007F') out[j++] = c;
}
return new String(out);
}
Эта вариация имеет то преимущество, что она правильна с использованием Normalizer и некоторой скоростью той, которая используется в таблице. На моей машине это примерно в 4 раза быстрее, чем принятый ответ, а от 6,6 до 7 раз медленнее, чем @virgo47 (принятый ответ примерно на 26 раз медленнее, чем @virgo47 на моей машине).
EDIT: Если вы не застряли с Java < 6, а скорость не является критичной, и/или таблица перевода слишком ограничена, используйте ответ Дэвида. Дело в том, чтобы использовать Normalizer (введенный в Java 6) вместо таблицы перевода внутри цикла.
Хотя это не "идеальное" решение, оно хорошо работает, когда вы знаете диапазон (в нашем случае Latin1,2), работали до Java 6 (это не настоящая проблема) и намного быстрее, чем самая рекомендуемая версия ( может быть или не быть проблемой):
/**
* Mirror of the unicode table from 00c0 to 017f without diacritics.
*/
private static final String tab00c0 = "AAAAAAACEEEEIIII" +
"DNOOOOO\u00d7\u00d8UUUUYI\u00df" +
"aaaaaaaceeeeiiii" +
"\u00f0nooooo\u00f7\u00f8uuuuy\u00fey" +
"AaAaAaCcCcCcCcDd" +
"DdEeEeEeEeEeGgGg" +
"GgGgHhHhIiIiIiIi" +
"IiJjJjKkkLlLlLlL" +
"lLlNnNnNnnNnOoOo" +
"OoOoRrRrRrSsSsSs" +
"SsTtTtTtUuUuUuUu" +
"UuUuWwYyYZzZzZzF";
/**
* Returns string without diacritics - 7 bit approximation.
*
* @param source string to convert
* @return corresponding string without diacritics
*/
public static String removeDiacritic(String source) {
char[] vysl = new char[source.length()];
char one;
for (int i = 0; i < source.length(); i++) {
one = source.charAt(i);
if (one >= '\u00c0' && one <= '\u017f') {
one = tab00c0.charAt((int) one - '\u00c0');
}
vysl[i] = one;
}
return new String(vysl);
}
Тесты на моем HW с 32-разрядным JDK показывают, что он выполняет преобразование из aeelstc89FDČ в aeelstc89FDC 1 миллион раз в ~ 100 мс, в то время как способ Normalizer делает его в 3.7s (37x медленнее). В случае, если ваши потребности вокруг производительности, и вы знаете диапазон ввода, это может быть для вас.
Наслаждайтесь: -)
System.out.println(Normalizer.normalize("àèé", Normalizer.Form.NFD).replaceAll("\\p{InCombiningDiacriticalMarks}+", ""));
работал у меня. Вывод фрагмента выше дает "aee", что я хотел, но
System.out.println(Normalizer.normalize("àèé", Normalizer.Form.NFD).replaceAll("[^\\p{ASCII}]", ""));
не заменил.
В зависимости от языка эти могут не считаться акцентами (которые меняют звук буквы), но диакритические знаки
https://en.wikipedia.org/wiki/Diacritic#Languages_with_letters_containing_diacritics
"Боснийский и хорватский имеют символы č, ć, đ, š и ž, которые считаются отдельными буквами и перечислены как таковые в словарях и других контекстах, в которых слова перечислены в алфавитном порядке".
Удаление их может по своей сути изменить значение слова или изменить буквы на совершенно разные.
Я предлагаю Junidecode. Он будет обрабатывать не только "Ł" и "Ø", но также хорошо подходит для переписывания из других алфавитов, таких как китайский, в латинский алфавит.
@Решение David Conrad является самым быстрым, с которым я пытался использовать Normalizer, но у него есть ошибка. Он в основном разделяет символы, которые не являются акцентами, например, китайские иероглифы и другие буквы, такие как æ, все лишены. Символы, которые мы хотим разбить, - это метки интервалов, символы, которые не занимают дополнительной ширины в финальной строке. Эти символы нулевой ширины в основном объединяются в какой-то другой символ. Если вы можете видеть их изолированными как символ, например, как это, я полагаю, что он сочетается с символом пробела.
public static String flattenToAscii(String string) {
char[] out = new char[string.length()];
String norm = Normalizer.normalize(string, Normalizer.Form.NFD);
int j = 0;
for (int i = 0, n = norm.length(); i < n; ++i) {
char c = norm.charAt(i);
int type = Character.getType(c);
//Log.d(TAG,""+c);
//by Ricardo, modified the character check for accents, ref: http://stackoverflow.com/a/5697575/689223
if (type != Character.NON_SPACING_MARK){
out[j] = c;
j++;
}
}
//Log.d(TAG,"normalized string:"+norm+"/"+new String(out));
return new String(out);
}
Я столкнулся с той же проблемой, связанной с проверкой равенства строк. Одна из строк сравнения Код символа ASCII 128-255.
i.e. Неразрывное пространство - [Hex - A0] Пространство [Hex - 20]. Показать Неразрывное пространство над HTML. Я использовал следующий
spacing entities. Их характер и его байты похожи на&emsp is very wide space[ ]{-30, -128, -125}, &ensp is somewhat wide space[ ]{-30, -128, -126}, &thinsp is narrow space[ ]{32} , Non HTML Space {}String s1 = "My Sample Space Data", s2 = "My Sample Space Data"; System.out.format("S1: %s\n", java.util.Arrays.toString(s1.getBytes())); System.out.format("S2: %s\n", java.util.Arrays.toString(s2.getBytes()));Выход в байтах:
S1: [77, 121,
32, 83, 97, 109, 112, 108, 101,32, 83, 112, 97, 99, 101,32, 68, 97, 116, 97] S2: [77, 121,-30, -128, -125, 83, 97, 109, 112, 108, 101,-30, -128, -125, 83, 112, 97, 99, 101,-30, -128, -125, 68, 97, 116, 97]
Используйте следующий код для разных пространств и их байтовых кодов: wiki for List_of_Unicode_characters
String spacing_entities = "very wide space,narrow space,regular space,invisible separator";
System.out.println("Space String :"+ spacing_entities);
byte[] byteArray =
// spacing_entities.getBytes( Charset.forName("UTF-8") );
// Charset.forName("UTF-8").encode( s2 ).array();
{-30, -128, -125, 44, -30, -128, -126, 44, 32, 44, -62, -96};
System.out.println("Bytes:"+ Arrays.toString( byteArray ) );
try {
System.out.format("Bytes to String[%S] \n ", new String(byteArray, "UTF-8"));
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
➩ Транслитерация ASCII строки Unicode для Java. unidecode
String initials = Unidecode.decode( s2 );
➩ с помощью Guava: Google Core Libraries for Java.
String replaceFrom = CharMatcher.WHITESPACE.replaceFrom( s2, " " );
Для URL-кодирования для пространства используйте Guava laibrary.
String encodedString = UrlEscapers.urlFragmentEscaper().escape(inputString);
➩ Чтобы преодолеть эту проблему, используйте String.replaceAll() с некоторым RegularExpression.
// \p{Z} or \p{Separator}: any kind of whitespace or invisible separator.
s2 = s2.replaceAll("\\p{Zs}", " ");
s2 = s2.replaceAll("[^\\p{ASCII}]", " ");
s2 = s2.replaceAll(" ", " ");
➩ Используя java.text.Normalizer.Form. Это перечисление содержит константы четырех форматов нормализации Unicode, которые описаны в Unicode Standard Annex № 15 - Unicode Normalization Forms и два метода доступа к ним.
s2 = Normalizer.normalize(s2, Normalizer.Form.NFKC);
Тестирование Строки и выходы на разных подходах, таких как ➩ Unidecode, Normalizer, StringUtils.
String strUni = "Tĥïŝ ĩš â fůňķŷ Šťŕĭńġ Æ,Ø,Ð,ß";
// This is a funky String AE,O,D,ss
String initials = Unidecode.decode( strUni );
// Following Produce this o/p: Tĥïŝ ĩš â fůňķŷ Šťŕĭńġ Æ,Ø,Ð,ß
String temp = Normalizer.normalize(strUni, Normalizer.Form.NFD);
Pattern pattern = Pattern.compile("\\p{InCombiningDiacriticalMarks}+");
temp = pattern.matcher(temp).replaceAll("");
String input = org.apache.commons.lang3.StringUtils.stripAccents( strUni );
Использование Unidecode - best choice, мой последний код, показанный ниже.
public static void main(String[] args) {
String s1 = "My Sample Space Data", s2 = "My Sample Space Data";
String initials = Unidecode.decode( s2 );
if( s1.equals(s2)) { //[ , ] %A0 - %2C - %20 « http://www.ascii-code.com/
System.out.println("Equal Unicode Strings");
} else if( s1.equals( initials ) ) {
System.out.println("Equal Non Unicode Strings");
} else {
System.out.println("Not Equal");
}
}
Один из лучших способов использования регулярных выражений и нормализатора, если у вас нет библиотеки, это:
public String flattenToAscii(String s) {
if(s == null || s.trim().length() == 0)
return "";
return Normalizer.normalize(s, Normalizer.Form.NFD).replaceAll("[\u0300-\u036F]", "");
}
Это более эффективно, чем replaceAll ("[^\p {ASCII}]", "")), и если вам не нужны диакритические знаки (как в вашем примере).
В противном случае вы должны использовать шаблон p {ASCII}.
С уважением.
В случае, если кто-то пытается сделать это в kotlin, этот код работает как шарм. Чтобы избежать несоответствий, я также использую .toUpperCase и Trim(). тогда я разыграл эту функцию:
fun stripAccents(s: String):String{
if (s == null) {
return "";
}
val chars: CharArray = s.toCharArray()
var sb = StringBuilder(s)
var cont: Int = 0
while (chars.size > cont) {
var c: kotlin.Char
c = chars[cont]
var c2:String = c.toString()
//these are my needs, in case you need to convert other accents just Add new entries aqui
c2 = c2.replace("Ã", "A")
c2 = c2.replace("Õ", "O")
c2 = c2.replace("Ç", "C")
c2 = c2.replace("Á", "A")
c2 = c2.replace("Ó", "O")
c2 = c2.replace("Ê", "E")
c2 = c2.replace("É", "E")
c2 = c2.replace("Ú", "U")
c = c2.single()
sb.setCharAt(cont, c)
cont++
}
return sb.toString()
}
чтобы использовать эти забавы, приведите такой код:
var str: String
str = editText.text.toString() //get the text from EditText
str = str.toUpperCase().trim()
str = stripAccents(str) //call the function