Existe-t-il un moyen de se débarrasser des accents et de convertir une chaîne entière en lettres régulières?

Existe-t-il un meilleur moyen de se débarrasser des accents et de rendre ces lettres régulières en dehors de l'utilisation de la String.replaceAll()méthode et du remplacement des lettres une par une? Exemple:

Contribution: orčpžsíáýd

Production: orcpzsiayd

Il n'a pas besoin d'inclure toutes les lettres avec des accents comme l'alphabet russe ou le chinois.

Utilisez java.text.Normalizerpour gérer cela pour vous.

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

Cela séparera toutes les marques d'accent des caractères. Ensuite, il vous suffit de comparer chaque caractère à une lettre et de jeter ceux qui ne le sont pas.

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

Si votre texte est en unicode, vous devez utiliser ceci à la place:

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

Pour unicode, \\P{M}correspond au glyphe de base et \\p{M}(en minuscules) correspond à chaque accent.

Merci à GarretWilson pour le pointeur et regular-expressions.info pour le grand guide unicode.

Depuis 2011, vous pouvez utiliser Apache Commons StringUtils.stripAccents (entrée) (depuis 3.0):

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

Remarque:

La réponse acceptée (celle d'Erick Robertson) ne fonctionne pas pour Ø ou £. Apache Commons 3.5 ne fonctionne pas non plus pour Ø, mais il fonctionne pour Ł. Après avoir lu l'article Wikipedia pour Ø , je ne suis pas sûr qu'il devrait être remplacé par "O": c'est une lettre distincte en norvégien et danois, alphabétisée après "z". C'est un bon exemple des limites de l'approche "strip accents".

La solution de @ virgo47 est très rapide, mais approximative. La réponse acceptée utilise Normalizer et une expression régulière. Je me demandais quelle partie du temps était prise par Normalizer par rapport à l'expression régulière, car la suppression de tous les caractères non ASCII peut se faire sans expression régulière:

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

De petites accélérations supplémentaires peuvent être obtenues en écrivant dans un char [] et en n'appelant pas toCharArray (), bien que je ne suis pas sûr que la diminution de la clarté du code le mérite:

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

Cette variation a l'avantage de la justesse de celle qui utilise le normalisateur et d'une partie de la vitesse de celle qui utilise une table. Sur ma machine, celle-ci est environ 4x plus rapide que la réponse acceptée, et 6,6x à 7x plus lente que celle de @ virgo47 (la réponse acceptée est environ 26 fois plus lente que @ virgo47 sur ma machine).

EDIT: Si vous n'êtes pas coincé avec Java <6 et que la vitesse n'est pas critique et / ou que la table de traduction est trop limitative, utilisez la réponse de David. Le point est d'utiliser Normalizer(introduit dans Java 6) au lieu de la table de traduction à l'intérieur de la boucle.

Bien que ce ne soit pas une solution "parfaite", cela fonctionne bien lorsque vous connaissez la gamme (dans notre cas Latin1,2), fonctionnait avant Java 6 (ce n'est pas un vrai problème cependant) et est beaucoup plus rapide que la version la plus suggérée (peut ou peut pas un problème):

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

Les tests sur mon HW avec JDK 32 bits montrent que cela effectue la conversion de àèéľšťč89FDČ à aeelstc89FDC 1 million de fois en ~ 100 ms tandis que le mode Normalizer le fait en 3,7 secondes (37 fois plus lentement). Si vos besoins concernent les performances et que vous connaissez la plage d'entrée, cela peut être pour vous.

Prendre plaisir :-)

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

travaillé pour moi. La sortie de l'extrait ci-dessus donne "aee" qui est ce que je voulais, mais

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

n'a fait aucune substitution.

Selon la langue, ceux-ci peuvent ne pas être considérés comme des accents (qui changent le son de la lettre), mais comme des signes diacritiques

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

"Le bosniaque et le croate portent les symboles č, ć, đ, š et ž, qui sont considérés comme des lettres distinctes et sont répertoriés comme tels dans les dictionnaires et autres contextes dans lesquels les mots sont répertoriés par ordre alphabétique."

Les supprimer peut être intrinsèquement changer le sens du mot, ou changer les lettres en des lettres complètement différentes.

J'ai rencontré le même problème lié à la vérification de l'égalité des chaînes, l'une des chaînes de comparaison a le code de caractère ASCII 128-255 .

ie, Espace insécable - [Hex - A0] Espace [Hex - 20]. Pour afficher l'espace insécable sur HTML. J'ai utilisé ce qui suit spacing entities. Leur caractère et ses octets sont comme&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()));

Sortie en octets:

S1: [77, 121,, 3283, 97, 109, 112, 108, 101,, 3283, 112, 97, 99, 101,, 3268, 97, 116, 97] S2: [77, 121,, -30, -128, -12583, 97, 109, 112, 108, 101,, -30, -128, -12583, 112, 97, 99, 101,, -30, -128, -12568, 97, 116, 97]

Utilisez le code ci-dessous pour différents espaces et leurs codes d'octets: 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 Translittérations ASCII de la chaîne Unicode pour Java. unidecode

  String initials = Unidecode.decode( s2 );

• ➩ en utilisant Guava: Google Core Libraries for Java.

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

  Pour le codage d'URL pour l'espace, utilisez la bibliothèque de goyaves.

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

• ➩ Pour surmonter ce problème utilisé String.replaceAll()avec certains 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(" ", " ");

• ➩ Utilisation de java.text.Normalizer.Form . Cette énumération fournit des constantes des quatre formulaires de normalisation Unicode qui sont décrits dans l' Annexe 15 de la norme Unicode - Formulaires de normalisation Unicode et deux méthodes pour y accéder.

  

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

Test de String et de sorties sur différentes approches comme ➩ 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 );

Utiliser Unidecode est le best choice, Mon code final illustré ci-dessous.

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

}

Je suggère Junidecode . Il gérera non seulement «Ł» et «Ø», mais il fonctionne également bien pour la transcription d'autres alphabets, tels que le chinois, en alphabet latin.

La solution @David Conrad est la plus rapide que j'ai essayée en utilisant le Normalizer, mais elle a un bug. Il supprime essentiellement les caractères qui ne sont pas des accents, par exemple les caractères chinois et d'autres lettres comme æ, sont tous supprimés. Les caractères que nous voulons supprimer sont des marques sans espacement, des caractères qui ne prennent pas de largeur supplémentaire dans la chaîne finale. Ces caractères de largeur nulle finissent essentiellement par être combinés dans un autre caractère. Si vous pouvez les voir isolés en tant que personnage, par exemple comme ceci `, je suppose que c'est combiné avec le caractère espace.

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

L'une des meilleures façons d' utiliser l'expression régulière et le normaliseur si vous n'avez pas de bibliothèque est:

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

C'est plus efficace que replaceAll ("[^ \ p {ASCII}]", "")) et si vous n'avez pas besoin de signes diacritiques (comme votre exemple).

Sinon, vous devez utiliser le modèle p {ASCII}.

Cordialement.

Je pense que la meilleure solution est de convertir chaque caractère en HEX et de le remplacer par un autre HEX. C'est parce qu'il existe 2 types Unicode:

Composite Unicode
Precomposed Unicode

Par exemple, "Ồ" écrit par Composic Unicode est différent de "Ồ" écrit par Precomposed Unicode. Vous pouvez copier mes exemples de caractères et les convertir pour voir la différence.

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

J'ai développé cette fonctionnalité pour que certaines banques convertissent les informations avant de les envoyer à la banque principale (ne prennent généralement pas en charge Unicode) et j'ai rencontré ce problème lorsque les utilisateurs finaux utilisent plusieurs types de caractères Unicode pour saisir les données. Je pense donc que la conversion en HEX et son remplacement est le moyen le plus fiable.

Si quelqu'un s'efforce de le faire dans kotlin, ce code fonctionne comme un charme. Pour éviter les incohérences, j'utilise également .toUpperCase et Trim (). alors je jette cette fonction:

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

}

pour utiliser ces amusants, lancez le code comme ceci:

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

     str = stripAccents(str) //call the function