Existe uma maneira de se livrar dos acentos e converter uma sequência inteira em letras regulares?

Existe uma maneira melhor de se livrar dos acentos e tornar essas letras regulares, além de usar o String.replaceAll()método e substituir as letras uma a uma? Exemplo:

Entrada: orčpžsíáýd

Resultado: orcpzsiayd

Não é necessário incluir todas as letras com acentos, como o alfabeto russo ou o chinês.

Use java.text.Normalizerpara lidar com isso para você.

string = Normalizer.normalize(string, Normalizer.Form.NFD);
// or Normalizer.Form.NFKD for a more "compatable" deconstruction 

Isso separará todas as marcas de destaque dos caracteres. Então, você só precisa comparar cada personagem com uma letra e jogar fora os que não são.

string = string.replaceAll("[^\\p{ASCII}]", "");

Se o seu texto estiver em unicode, você deve usá-lo:

string = string.replaceAll("\\p{M}", "");

Para unicode, \\P{M}corresponde ao glifo base e \\p{M}(em minúsculas) corresponde a cada acento.

Agradecemos a GarretWilson pelo ponteiro e regular-expressions.info pelo excelente guia unicode.

A partir de 2011, você pode usar o Apache Commons StringUtils.stripAccents (input) (desde 3.0):

    String input = StringUtils.stripAccents("Tĥïŝ ĩš â fůňķŷ Šťŕĭńġ");
    System.out.println(input);
    // Prints "This is a funky String"

Nota:

A resposta aceita (Erick Robertson) não funciona para Ø ou Ł. O Apache Commons 3.5 também não funciona para Ø, mas funciona para Ł. Depois de ler o artigo da Wikipedia sobre Ø , não tenho certeza se deve ser substituído por "O": é uma letra separada em norueguês e dinamarquês, alfabetizada após "z". É um bom exemplo das limitações da abordagem "tira sotaques".

A solução do @ virgo47 é muito rápida, mas aproximada. A resposta aceita usa o Normalizador e uma expressão regular. Gostaria de saber qual parte do tempo foi gasta pelo Normalizer versus a expressão regular, pois a remoção de todos os caracteres não ASCII pode ser feita sem uma expressão regular:

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();
    }
}

Pequenas acelerações adicionais podem ser obtidas escrevendo um char [] e não chamandoCharCharrray (), embora eu não tenha certeza de que a diminuição na clareza do código o mereça:

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);
}

Essa variação tem a vantagem da correção de quem usa o Normalizer e da velocidade de quem usa uma tabela. Na minha máquina, essa é cerca de 4x mais rápida que a resposta aceita e 6,6x a 7x mais lenta que a @ virgo47 (a resposta aceita é 26x mais lenta que a @ virgo47 na minha máquina).

EDIT: Se você não está preso ao Java <6 e a velocidade não é crítica e / ou a tabela de conversão é muito limitadora, use a resposta de David. O objetivo é usar Normalizer(introduzido no Java 6) em vez da tabela de conversão dentro do loop.

Embora essa não seja uma solução "perfeita", ela funciona bem quando você conhece o intervalo (no nosso caso, Latin1,2), trabalhou antes do Java 6 (embora não seja um problema real) e é muito mais rápido que a versão mais sugerida (pode ou pode não seja um problema):

    /**
 * 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);
}

Testes no meu HW com JDK de 32 bits mostram que isso realiza a conversão de àèéľšťč89FDČ para aeelstc89FDC 1 milhão de vezes em ~ 100ms, enquanto o modo Normalizador o torna em 3,7s (37x mais lento). Caso suas necessidades estejam relacionadas ao desempenho e você saiba o intervalo de entrada, isso pode ser para você.

Aproveitar :-)

System.out.println(Normalizer.normalize("àèé", Normalizer.Form.NFD).replaceAll("\\p{InCombiningDiacriticalMarks}+", ""));

trabalhou para mim. A saída do snippet acima fornece "aee", que é o que eu queria, mas

System.out.println(Normalizer.normalize("àèé", Normalizer.Form.NFD).replaceAll("[^\\p{ASCII}]", ""));

não fez nenhuma substituição.

Dependendo do idioma, esses podem não ser considerados acentos (que alteram o som da letra), mas marcas diacríticas

https://en.wikipedia.org/wiki/Diacritic#Languages_with_letters_containing_diacritics

"Bósnio e croata têm os símbolos č, ć, đ, š e ž, que são considerados letras separadas e são listados como tal em dicionários e outros contextos nos quais as palavras são listadas de acordo com a ordem alfabética."

Removê-los pode estar inerentemente alterando o significado da palavra ou mudando as letras para letras completamente diferentes.

Eu enfrentei o mesmo problema relacionado à verificação de igualdade de Strings. Uma das strings de comparação possui o código de caracteres ASCII 128-255 .

ou seja, Espaço sem quebra - [Hex - A0] Espaço [Hex - 20]. Para mostrar espaço sem interrupção sobre HTML. Eu usei o seguinte spacing entities. Seu caráter e seus bytes são como&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()));

Saída em bytes:

S1: [77, 121,, 3283, 97, 109, 112, 108, 101,, 3283, 112, 97, 99, 101 32, 68, 97, 116, 97] S2: [77, 121 -30, -128, -125, 83, 97, 109, 112, 108, 101, -30, -128, -12583, 112, 97, 99, 101 -30, -128, -125, 68, 97, 116, 97]

Use o código abaixo para diferentes espaços e seus códigos de bytes: 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();
}

• Transl Transliterações ASCII da cadeia Unicode para Java. unidecode

  String initials = Unidecode.decode( s2 );

• ➩ usando Guava: Google Core Libraries for Java.

  String replaceFrom = CharMatcher.WHITESPACE.replaceFrom( s2, " " );

  Para codificação de URL para o espaço, use Guava laibrary.

  String encodedString = UrlEscapers.urlFragmentEscaper().escape(inputString);

• ➩ Para superar esse problema usado String.replaceAll()com alguns 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(" ", " ");

• ➩ Usando java.text.Normalizer.Form . Essa enumeração fornece constantes dos quatro formulários de normalização Unicode descritos no Anexo Padrão 15 do Unicode - Formulários de Normalização Unicode e dois métodos para acessá-los.

  

  s2 = Normalizer.normalize(s2, Normalizer.Form.NFKC);

Testando String e saídas em diferentes abordagens, como id 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 );

Usando Unidecode é o best choice, Meu código final mostrado abaixo.

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");
    }

}

Eu sugiro Junidecode . Ele manipulará não apenas 'Ł' e 'Ø', mas também funcionará bem para transcrever de outros alfabetos, como o chinês, para o alfabeto latino.

A solução @David Conrad é a mais rápida que tentei usar o Normalizer, mas tem um bug. Ele basicamente retira caracteres que não são acentuados, por exemplo, caracteres chineses e outras letras como æ, são todos removidos. Os caracteres que queremos extrair são marcas sem espaçamento, caracteres que não ocupam largura extra na sequência final. Esses caracteres de largura zero basicamente acabam combinados em algum outro caractere. Se você pode vê-los isolados como um personagem, por exemplo, `` meu palpite é que é combinado com o caractere de espaço.

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);
}

Uma das melhores maneiras de usar o regex e o Normalizer se você não tiver uma biblioteca é:

    public String flattenToAscii(String s) {
                if(s == null || s.trim().length() == 0)
                        return "";
                return Normalizer.normalize(s, Normalizer.Form.NFD).replaceAll("[\u0300-\u036F]", "");
}

Isso é mais eficiente que replaceAll ("[^ \ p {ASCII}]", "")) e se você não precisar de sinais diacríticos (como no seu exemplo).

Caso contrário, você precisará usar o padrão p {ASCII}.

Saudações.

Eu acho que a melhor solução é converter cada caractere para HEX e substituí-lo por outro HEX. É porque existem 2 digitações Unicode:

Composite Unicode
Precomposed Unicode

Por exemplo, "Ồ" escrito por Composite Unicode é diferente de "Ồ" escrito por Precomposed Unicode. Você pode copiar meus caracteres de amostra e convertê-los para ver a diferença.

In Composite Unicode, "Ồ" is combined from 2 char: Ô (U+00d4) and ̀ (U+0300)
In Precomposed Unicode, "Ồ" is single char (U+1ED2)

Desenvolvi esse recurso para alguns bancos para converter as informações antes de enviá-las ao banco central (geralmente não suportam Unicode) e enfrentei esse problema quando os usuários finais usam várias digitações Unicode para inserir os dados. Então eu acho que converter para HEX e substituí-lo é a maneira mais confiável.

Caso alguém esteja lutando para fazer isso no kotlin, esse código funcionará como um encanto. Para evitar inconsistências, também uso .toUpperCase e Trim (). então eu lancei esta função:

   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()

}

Para usá-los, transmita o código da seguinte maneira:

     var str: String
     str = editText.text.toString() //get the text from EditText
     str = str.toUpperCase().trim()

     str = stripAccents(str) //call the function