Có cách nào để loại bỏ các dấu và chuyển đổi toàn bộ chuỗi thành các chữ cái thông thường không?

Có cách nào tốt hơn để loại bỏ các dấu và làm cho các chữ cái đó thường xuyên ngoài việc sử dụng String.replaceAll()phương thức và thay thế từng chữ cái một không? Thí dụ:

Đầu vào: orčpžsíáýd

Đầu ra: orcpzsiayd

Không cần bao gồm tất cả các chữ cái có dấu như bảng chữ cái tiếng Nga hoặc chữ Trung Quốc.

Sử dụng java.text.Normalizerđể xử lý này cho bạn.

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

Điều này sẽ tách tất cả các dấu trọng âm từ các nhân vật. Sau đó, bạn chỉ cần so sánh từng nhân vật với việc là một chữ cái và loại bỏ những ký tự không có.

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

Nếu văn bản của bạn ở dạng unicode, bạn nên sử dụng thay thế này:

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

Đối với unicode, \\P{M}khớp với glyph cơ sở và \\p{M}(chữ thường) khớp với từng dấu.

Nhờ GarretWilson cho con trỏ và regular-expressions.info cho hướng dẫn unicode tuyệt vời.

Kể từ năm 2011, bạn có thể sử dụng Apache Commons StringUtils.stripAccents (đầu vào) (kể từ 3.0):

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

Ghi chú:

Câu trả lời được chấp nhận (Erick Robertson's) không hoạt động cho Ø hoặc. Apache Commons 3.5 không hoạt động cho, nhưng nó hoạt động cho. Sau khi đọc bài viết Wikipedia cho , tôi không chắc nó nên được thay thế bằng "O": đó là một chữ cái riêng trong tiếng Na Uy và tiếng Đan Mạch, được sắp xếp theo thứ tự chữ cái sau "z". Đó là một ví dụ tốt về những hạn chế của phương pháp "điểm nhấn dải".

Giải pháp của @ virgo47 rất nhanh, nhưng gần đúng. Câu trả lời được chấp nhận sử dụng Trình chuẩn hóa và biểu thức chính quy. Tôi đã tự hỏi phần nào thời gian được sử dụng bởi Trình chuẩn hóa so với biểu thức thông thường, vì việc xóa tất cả các ký tự không phải ASCII có thể được thực hiện mà không cần biểu thức chính quy:

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

Tăng tốc độ bổ sung nhỏ có thể đạt được bằng cách viết vào char [] và không gọi tới CharArray (), mặc dù tôi không chắc rằng việc giảm độ rõ của mã có xứng đáng với nó không:

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

Biến thể này có lợi thế về tính chính xác của cách sử dụng Trình chuẩn hóa và một số tốc độ của bảng sử dụng bảng. Trên máy của tôi, câu hỏi này nhanh hơn khoảng 4 lần so với câu trả lời được chấp nhận và chậm hơn 6,6 lần đến 7 lần so với câu trả lời của @ virgo47 (câu trả lời được chấp nhận chậm hơn khoảng 26 lần so với @ virgo47 trên máy của tôi).

EDIT: Nếu bạn không bị mắc kẹt với Java <6 và tốc độ không quan trọng và / hoặc bảng dịch quá giới hạn, hãy sử dụng câu trả lời của David. Vấn đề là sử dụng Normalizer(được giới thiệu trong Java 6) thay vì bảng dịch bên trong vòng lặp.

Mặc dù đây không phải là giải pháp "hoàn hảo", nhưng nó hoạt động tốt khi bạn biết phạm vi (trong trường hợp của chúng tôi là Latin1,2), hoạt động trước Java 6 (không phải là vấn đề thực sự) và nhanh hơn nhiều so với phiên bản được đề xuất nhất (có thể hoặc có thể không phải là một vấn đề):

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

Các thử nghiệm trên CTNH của tôi với JDK 32 bit cho thấy điều này thực hiện chuyển đổi từ àèéľšťč89FDČ sang aeelstc89FDC 1 triệu lần trong ~ 100ms trong khi cách Trình chuẩn hóa thực hiện trong 3,7 giây (chậm hơn 37 lần). Trong trường hợp nhu cầu của bạn xoay quanh hiệu suất và bạn biết phạm vi đầu vào, điều này có thể dành cho bạn.

Thưởng thức :-)

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

đã làm cho tôi. Đầu ra của đoạn trích trên cho "aee" là thứ tôi muốn, nhưng

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

đã không làm bất kỳ thay thế.

Tùy thuộc vào ngôn ngữ, những từ đó có thể không được coi là dấu (làm thay đổi âm của chữ cái), nhưng dấu phụ

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

"Bosnian và Croatia có các ký hiệu č, ć, đ, š và ž, được coi là các chữ cái riêng biệt và được liệt kê như vậy trong từ điển và các bối cảnh khác trong đó các từ được liệt kê theo thứ tự bảng chữ cái."

Loại bỏ chúng có thể là thay đổi ý nghĩa của từ hoặc thay đổi các chữ cái thành những từ hoàn toàn khác nhau.

Tôi đã phải đối mặt với cùng một vấn đề liên quan đến kiểm tra tính bằng nhau của Chuỗi, Một trong những chuỗi so sánh có mã ký tự ASCII 128-255 .

tức là không gian không phá vỡ - [Hex - A0] Space [Hex - 20]. Để hiển thị không gian không phá vỡ trên HTML. Tôi đã sử dụng như sau spacing entities. Nhân vật của họ và byte của nó giống như&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()));

Đầu ra tính bằng byte:

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]

Sử dụng mã dưới đây cho các không gian khác nhau và mã byte của chúng: 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();
}

• Phiên âm ASCII của chuỗi Unicode cho Java. unidecode

  String initials = Unidecode.decode( s2 );

• Sử dụng Guava: Google Core Libraries for Java.

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

  Đối với mã hóa URL cho không gian, hãy sử dụng phép lai Guava.

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

• Để khắc phục vấn đề này được sử dụng String.replaceAll()với một số 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(" ", " ");

• Sử dụng java.text.N normalizer.Form . Enum này cung cấp các hằng số của bốn biểu mẫu chuẩn hóa Unicode được mô tả trong Phụ lục tiêu chuẩn Unicode # 15 - Biểu mẫu chuẩn hóa Unicode và hai phương thức để truy cập chúng.

  

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

Kiểm tra Chuỗi và đầu ra trên các phương pháp khác nhau như ➩ 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 );

Sử dụng Unidecode là best choice, Mã cuối cùng của tôi được hiển thị bên dưới.

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

}

Tôi đề nghị Junidecode . Nó sẽ xử lý không chỉ '' và 'Ø', mà còn hoạt động tốt để phiên âm từ các bảng chữ cái khác, chẳng hạn như tiếng Trung Quốc, sang bảng chữ cái Latinh.

Giải pháp @David Conrad là giải pháp nhanh nhất tôi đã thử sử dụng Trình chuẩn hóa, nhưng nó có một lỗi. Về cơ bản, nó loại bỏ các ký tự không phải là dấu, ví dụ như các ký tự Trung Quốc và các chữ cái khác như, đều bị tước bỏ. Các ký tự mà chúng tôi muốn tách là các dấu không cách nhau, các ký tự không chiếm thêm độ rộng trong chuỗi cuối cùng. Các ký tự có chiều rộng bằng không này về cơ bản kết thúc trong một số ký tự khác. Nếu bạn có thể thấy chúng bị cô lập như một nhân vật, ví dụ như thế này `, tôi đoán là nó được kết hợp với nhân vật không gian.

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

Một trong những cách tốt nhất để sử dụng regex và Trình chuẩn hóa nếu bạn không có thư viện là:

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

Điều này hiệu quả hơn thay thế All ("[^ \ p {ASCII}]", "")) và nếu bạn không cần dấu phụ (giống như ví dụ của bạn).

Mặt khác, bạn phải sử dụng mẫu p {ASCII}.

Trân trọng.

Tôi nghĩ giải pháp tốt nhất là chuyển đổi từng char thành HEX và thay thế nó bằng một HEX khác. Đó là bởi vì có 2 kiểu gõ Unicode:

Composite Unicode
Precomposed Unicode

Ví dụ: "Xóa" được viết bởi Unicode tổng hợp khác với "Xóa" được viết bởi Unicode được phân tách trước. Bạn có thể sao chép ký tự mẫu của tôi và chuyển đổi chúng để thấy sự khác biệt.

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

Tôi đã phát triển tính năng này cho một số ngân hàng để chuyển đổi thông tin trước khi gửi nó đến ngân hàng lõi (thường không hỗ trợ Unicode) và gặp phải vấn đề này khi người dùng cuối sử dụng nhiều kiểu gõ Unicode để nhập dữ liệu. Vì vậy, tôi nghĩ rằng, chuyển đổi sang HEX và thay thế nó là cách đáng tin cậy nhất.

Trong trường hợp bất cứ ai đang cố gắng để làm điều này trong kotlin, mã này hoạt động như một lá bùa. Để tránh mâu thuẫn, tôi cũng sử dụng .toUpperCase và Trim (). sau đó tôi bỏ chức năng này:

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

}

để sử dụng những đoạn mã thú vị như thế này:

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

     str = stripAccents(str) //call the function