¿Cómo imitar la transliteración en Java?

Question

En Perl, suelo utilizar la transliteración para contar el número de caracteres de una cadena que coinciden con un conjunto de caracteres posibles.Cosas como:

$c1=($a =~ y[\x{0410}-\x{042F}\x{0430}-\x{044F}]
            [\x{0410}-\x{042F}\x{0430}-\x{044F}]);

contaría el número de caracteres cirílicos en $a.Como en el ejemplo anterior tengo dos clases (o dos rangos, si lo prefieres), tengo alguna otra con algunas clases más:

$c4=($a =~ y[\x{AC00}-\x{D7AF}\x{1100}-\x{11FF}\x{3130}-\x{318F}\x{A960}-\x{A97F}\x{D7B0}-\x{D7FF}]
            [\x{AC00}-\x{D7AF}\x{1100}-\x{11FF}\x{3130}-\x{318F}\x{A960}-\x{A97F}\x{D7B0}-\x{D7FF}]);

Ahora necesito hacer algo similar en Java.¿Existe una construcción similar en Java?¿O necesito iterar sobre todos los personajes y comprobar si está entre los límites de cada clase?

Gracias

Answer 1

no he visto nada como tr/// en Java.

Podrías usar algo como esto para contar todos los coincidencias Tho:

Pattern p = Pattern.compile("[\\x{0410}-\\x{042F}\\x{0430}-\\x{044F}]", 
                            Pattern.CANON_EQ);
Matcher m = p.matcher(string);
int count = 0;
while (m.find())
    count++;

Answer 2

Para buen orden:utilizando el soporte Java Unicode.

int countCyrillic(String s) {
    int n = 0;
    for (int i = 0; i < s.length(); ) {
        int codePoint = s.codePointAt(i);
        i += Character.charCount(codePoint);
        if (UnicodeScript.of(codePoint) == UnicodeScript.CYRILLIC) {
            ++n;
        }
    }
    return n;
}

Esto usa el unicode completo (donde dos caracteres de 16 bits pueden representar un "punto de código" de Unicode. Y en Java el carácter de clase. Unicodescript ya tiene todo lo que necesita.

O:

int n = s.replaceAll("\\P{CYRILLIC}", "").length();

Aquí \\P es el negativo de \\p{CYRILLIC} el grupo cirílico.

Answer 3

Puedes intentar jugar con algo así:

s.replaceAll( "[^\x{0410}-\x{042F}\x{0430}-\x{044F}]*([\x{0410}-\x{042F}\x{0430}-\x{044F}])?", "$1" ).length()

La idea fue prestada desde aquí: forma sencilla de contarocurrencias de carácter en una cadena