มีวิธีกำจัดสำเนียงและแปลงสตริงทั้งหมดเป็นตัวอักษรปกติหรือไม่?

มีวิธีที่ดีกว่าสำหรับการกำจัดสำเนียงและทำให้ตัวอักษรเหล่านั้นเป็นประจำนอกเหนือจากการใช้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}]", "");

หากข้อความของคุณอยู่ในยูนิโค้ดคุณควรใช้สิ่งนี้แทน:

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

สำหรับยูนิโค้ด\\P{M}ตรงกับสัญลักษณ์ฐานและ\\p{M}(ตัวพิมพ์เล็ก) ตรงกับแต่ละสำเนียง

ขอขอบคุณที่ GarretWilson สำหรับตัวชี้และregular-expressions.infoสำหรับคู่มือ Unicode ที่ดี

ตั้งแต่ปี 2011 คุณสามารถใช้ Apache Commons StringUtils.stripAccents (อินพุต) (ตั้งแต่ 3.0):

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

บันทึก:

คำตอบที่ได้รับการยอมรับ (Erick Robertson) ไม่ทำงานสำหรับØหรือŁ Apache Commons 3.5 ใช้งานไม่ได้กับØ แต่ใช้งานได้กับŁ หลังจากอ่านบทความ Wikipedia สำหรับØฉันไม่แน่ใจว่าควรแทนที่ด้วย "O": เป็นจดหมายที่แยกต่างหากในนอร์เวย์และเดนมาร์กตามตัวอักษร "z" มันเป็นตัวอย่างที่ดีของข้อ จำกัด ของวิธีการ "เน้นเสียง"

วิธีแก้ปัญหาโดย @ virgo47 นั้นรวดเร็วมาก แต่โดยประมาณ คำตอบที่ยอมรับใช้ Normalizer และนิพจน์ทั่วไป ฉันสงสัยว่า Normalizer ส่วนใดที่ใช้เวลากับนิพจน์ทั่วไปเนื่องจากการลบอักขระที่ไม่ใช่ ASCII ทั้งหมดสามารถทำได้โดยไม่ต้อง 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();
    }
}

การเร่งความเร็วเพิ่มเติมเล็กน้อยสามารถทำได้โดยการเขียนลงในอักขระ [] และไม่เรียกไปที่ CharArray () ถึงแม้ว่าฉันไม่แน่ใจว่าการลดความชัดเจนของโค้ดจะทำสิ่งใด:

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 และความเร็วของการใช้ตาราง บนเครื่องของฉันอันนี้เร็วกว่าคำตอบที่ยอมรับประมาณ 4x และ 6.6x ถึง 7x ช้ากว่านั้นที่ @ virgo47 (คำตอบที่ยอมรับคือประมาณ 26x ช้ากว่า @ virgo47 บนเครื่องของฉัน)

แก้ไข: หากคุณไม่ได้ติดกับ Java <6 และความเร็วไม่สำคัญและ / หรือตารางการแปล จำกัด เกินไปให้ใช้คำตอบของ David จุดคือการใช้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 ของฉันด้วย 32bit JDK แสดงว่าการดำเนินการแปลงจากàèéľšťč89FDČเป็น aeelstc89FDC 1 ล้านครั้งใน ~ 100ms ในขณะที่ Normalizer ทำให้ 3.7 วินาที (ช้าลง 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

"บอสเนียและโครเอเชียมีสัญลักษณ์č, ć, đ, šและžซึ่งถือว่าเป็นตัวอักษรที่แยกต่างหากและมีการระบุไว้ในพจนานุกรมและบริบทอื่น ๆ ที่มีการระบุคำตามลำดับตัวอักษร"

การลบออกอาจเป็นการเปลี่ยนความหมายของคำโดยเนื้อแท้หรือการเปลี่ยนตัวอักษรเป็นสิ่งที่แตกต่างอย่างสิ้นเชิง

ฉันประสบปัญหาเดียวกันกับการตรวจสอบความเท่าเทียมกันของสตริงหนึ่งในสตริงเปรียบเทียบมี รหัสอักขระ ASCII 128-255128-255

นั่นคือพื้นที่ไม่แตกหัก - [Hex - A0] Space [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,, 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]

ใช้รหัสด้านล่างสำหรับช่องว่างที่แตกต่างกันและรหัสไบต์: 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();
}

• iter ตัวแปล ASCII ของสตริง Unicode สำหรับ Java unidecode

  String initials = Unidecode.decode( s2 );

• ➩ใช้Guava: Google 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 enum นี้แสดงค่าคงที่ของฟอร์มมาตรฐาน Unicode สี่รูปแบบที่อธิบายไว้ในUnicode Standard Annex # 15 - ฟอร์ม Normalization Unicode และสองวิธีในการเข้าถึง

  

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

}

ผมขอแนะนำให้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);
}

หนึ่งในวิธีที่ดีที่สุดในการใช้ regex และ Normalizerหากคุณไม่มีไลบรารี่คือ:

    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}

ความนับถือ.

ฉันคิดว่าทางออกที่ดีที่สุดคือแปลงถ่านแต่ละตัวเป็น HEX และแทนที่ด้วย HEX อื่น มันเป็นเพราะมีการพิมพ์ 2 Unicode:

Composite Unicode
Precomposed Unicode

ตัวอย่างเช่น "Ồ" เขียนโดยคอมโพสิต Unicode นั้นแตกต่างจาก "Ồ" ที่เขียนโดย Precomposed Unicode คุณสามารถคัดลอกตัวอย่างของฉันและแปลงเพื่อดูความแตกต่าง

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

ฉันได้พัฒนาฟีเจอร์นี้สำหรับบางธนาคารในการแปลงข้อมูลก่อนที่จะส่งไปยัง core-bank (มักจะไม่รองรับ Unicode) และประสบปัญหานี้เมื่อผู้ใช้ปลายทางใช้ Unicode หลาย ๆ ตัวเพื่อป้อนข้อมูล ดังนั้นฉันคิดว่าการแปลงเป็น HEX และแทนที่เป็นวิธีที่น่าเชื่อถือที่สุด

ในกรณีที่ทุกคนกำลังดิ้นรนเพื่อทำสิ่งนี้ใน 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