Apakah ada cara untuk menghilangkan aksen dan mengubah seluruh string menjadi huruf biasa?

Apakah ada cara yang lebih baik untuk menghilangkan aksen dan membuat surat-surat itu teratur selain menggunakan String.replaceAll()metode dan mengganti huruf satu per satu? Contoh:

Memasukkan: orčpžsíáýd

Keluaran: orcpzsiayd

Tidak perlu menyertakan semua huruf dengan aksen seperti alfabet Rusia atau yang Cina.

Gunakan java.text.Normalizeruntuk menangani ini untuk Anda.

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

Ini akan memisahkan semua tanda aksen dari karakter. Kemudian, Anda hanya perlu membandingkan setiap karakter dengan menjadi huruf dan membuang yang tidak.

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

Jika teks Anda berada dalam unicode, Anda harus menggunakan ini sebagai gantinya:

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

Untuk unicode, \\P{M}cocok dengan mesin terbang dasar dan \\p{M}(huruf kecil) cocok dengan masing-masing aksen.

Terima kasih kepada GarretWilson untuk penunjuk dan regular-expressions.info untuk panduan unicode yang hebat.

Pada 2011 Anda dapat menggunakan Apache Commons StringUtils.stripAccents (input) (sejak 3.0):

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

catatan:

Jawaban yang diterima (Erick Robertson) tidak berfungsi untuk Ø atau Ł. Apache Commons 3.5 juga tidak berfungsi untuk Ø, tetapi ia berfungsi untuk Ł. Setelah membaca artikel Wikipedia untuk Ø , saya tidak yakin itu harus diganti dengan "O": ini adalah huruf terpisah dalam bahasa Norwegia dan Denmark, diurutkan berdasarkan abjad setelah "z". Ini adalah contoh yang baik dari keterbatasan pendekatan "aksen strip".

Solusi oleh @ virgo47 sangat cepat, tetapi perkiraan. Jawaban yang diterima menggunakan Normalizer dan ekspresi reguler. Saya bertanya-tanya bagian waktu apa yang diambil oleh Normalizer versus ekspresi reguler, karena menghapus semua karakter non-ASCII dapat dilakukan tanpa regex:

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

Speed-up tambahan kecil dapat diperoleh dengan menulis ke char [] dan tidak memanggil toCharArray (), meskipun saya tidak yakin bahwa penurunan kejelasan kode layak untuk itu:

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

Variasi ini memiliki keunggulan kebenaran yang menggunakan Normalizer dan beberapa kecepatan yang menggunakan tabel. Di komputer saya, yang ini sekitar 4x lebih cepat dari jawaban yang diterima, dan 6,6x ke 7x lebih lambat dari yang @ virgo47's (jawaban yang diterima adalah sekitar 26x lebih lambat dari @ virgo47 di mesin saya).

EDIT: Jika Anda tidak terjebak dengan Java <6 dan kecepatan tidak kritis dan / atau tabel terjemahan terlalu terbatas, gunakan jawaban oleh David. Intinya adalah menggunakanNormalizer (diperkenalkan di Java 6) alih-alih tabel terjemahan di dalam loop.

Meskipun ini bukan solusi "sempurna", ini bekerja dengan baik ketika Anda tahu kisaran (dalam kasus kami Latin1,2), bekerja sebelum Java 6 (bukan masalah sebenarnya) dan jauh lebih cepat daripada versi yang paling disarankan (mungkin atau mungkin tidak menjadi masalah):

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

Tes pada HW saya dengan 32bit JDK menunjukkan bahwa ini melakukan konversi dari àèľšťč89FDČ ke aeelstc89FDC 1 juta kali dalam ~ 100ms sementara cara Normalizer membuatnya dalam 3,7s (37x lebih lambat). Jika kebutuhan Anda berada di sekitar kinerja dan Anda tahu kisaran input, ini mungkin untuk Anda.

Nikmati :-)

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

bekerja untukku. Output dari cuplikan di atas memberikan "aee" yang memang saya inginkan, tetapi

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

tidak melakukan substitusi.

Bergantung pada bahasanya, itu mungkin tidak dianggap aksen (yang mengubah bunyi surat), tetapi tanda diakritik

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

"Bahasa Bosnia dan Kroasia memiliki simbol č, ć, đ, š, dan ž, yang dianggap sebagai huruf terpisah dan didaftar seperti itu dalam kamus dan konteks lain di mana kata-kata terdaftar sesuai dengan urutan abjad."

Menghapusnya mungkin secara inheren mengubah arti kata, atau mengubah huruf menjadi yang sangat berbeda.

Saya telah menghadapi masalah yang sama terkait dengan pemeriksaan persamaan Strings, Salah satu string pembanding memiliki kode karakter ASCII 128-255 .

yaitu ruang Non-breaking - [Hex - A0] Space [Hex - 20]. Untuk menampilkan ruang tanpa putus di atas HTML. Saya telah menggunakan yang berikut ini spacing entities. Karakter dan byte mereka seperti&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()));

Output dalam 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]

Gunakan kode di bawah ini untuk Ruang yang Berbeda dan Kode-Byte mereka: 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();
}

• ➩ transliterasi string Unicode ASCII untuk Java. unidecode

  String initials = Unidecode.decode( s2 );

• ➩ menggunakan Guava: Google Core Libraries for Java.

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

  Untuk penyandian URL untuk ruang gunakan laibrary Guava.

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

• ➩ Untuk mengatasi masalah ini digunakan String.replaceAll()dengan beberapa 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(" ", " ");

• ➩ Menggunakan java.text.Normalizer.Form . Enum ini memberikan konstanta dari empat bentuk normalisasi Unicode yang dijelaskan dalam Unicode Standard Annex # 15 - Bentuk Normalisasi Unicode dan dua metode untuk mengaksesnya.

  

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

Menguji String dan output pada pendekatan berbeda seperti ➩ 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 );

Menggunakan Unidecode adalah best choice, Kode akhir saya ditunjukkan di bawah ini.

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

}

Saya menyarankan Junidecode . Ini tidak hanya akan menangani 'Ł' dan 'Ø', tetapi juga berfungsi dengan baik untuk menyalin dari huruf lain, seperti Cina, ke alfabet Latin.

@ David Conrad solusi adalah yang tercepat saya mencoba menggunakan Normalizer, tetapi memang memiliki bug. Ini pada dasarnya menelanjangi karakter yang bukan aksen, misalnya karakter Cina dan huruf lain seperti æ, semuanya dilucuti. Karakter yang ingin kita hapus adalah tanda tanpa spasi, karakter yang tidak mengambil lebar ekstra dalam string terakhir. Karakter nol lebar ini pada dasarnya digabungkan dalam beberapa karakter lain. Jika Anda dapat melihat mereka terisolasi sebagai karakter, misalnya seperti ini `, tebakan saya adalah bahwa itu dikombinasikan dengan karakter spasi.

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

Salah satu cara terbaik menggunakan regex dan Normalizer jika Anda tidak memiliki perpustakaan adalah:

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

Ini lebih efisien daripada replaceAll ("[^ \ p {ASCII}]", "")) dan jika Anda tidak memerlukan diakritik (seperti contoh Anda).

Jika tidak, Anda harus menggunakan pola p {ASCII}.

Salam.

Saya pikir solusi terbaik adalah mengkonversi masing-masing char ke HEX dan menggantinya dengan HEX lain Itu karena ada 2 pengetikan Unicode:

Composite Unicode
Precomposed Unicode

Misalnya "Ồ" yang ditulis oleh Unicode Komposit berbeda dari "Ồ" yang ditulis oleh Unicomp Precomposed. Anda dapat menyalin karakter sampel saya dan mengonversinya untuk melihat perbedaannya.

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

Saya telah mengembangkan fitur ini untuk beberapa bank untuk mengkonversi informasi sebelum mengirimnya ke bank inti (biasanya tidak mendukung Unicode) dan menghadapi masalah ini ketika pengguna akhir menggunakan beberapa pengetikan Unicode untuk memasukkan data. Jadi saya pikir, mengonversi ke HEX dan menggantinya adalah cara yang paling dapat diandalkan.

Jika ada orang yang berusaha melakukan ini di kotlin, kode ini berfungsi seperti mantra. Untuk menghindari ketidakkonsistenan, saya juga menggunakan .toUpperCase dan Trim (). maka saya menggunakan fungsi ini:

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

}

untuk menggunakan ini, berikan kode seperti ini:

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

     str = stripAccents(str) //call the function