Comment puis-je remplacer des caractères Unicode non imprimables en Java?

Ce qui suit remplacera les caractères de contrôle ASCII (raccourci pour [\x00-\x1F\x7F]):

my_string.replaceAll("\\p{Cntrl}", "?");

Ce qui suit remplacera tous les caractères ASCII non imprimables (raccourci pour [\p{Graph}\x20]), y compris les caractères accentués:

my_string.replaceAll("[^\\p{Print}]", "?");

Cependant, ni l'un ni l'autre ne fonctionne pour les chaînes Unicode. Quelqu'un a-t-il un bon moyen de supprimer les caractères non imprimables d'une chaîne Unicode?

my_string.replaceAll("\\p{C}", "?");

En savoir plus sur les expressions régulières Unicode . java.util.regexPattern/ les String.replaceAllsoutient.

L'Op De Cirkel a généralement raison. Sa suggestion fonctionnera dans la plupart des cas:

myString.replaceAll("\\p{C}", "?");

Mais si myStringpeut contenir des points de code non BMP, c'est plus compliqué. \p{C}contient les points de code de substitution de \p{Cs}. La méthode de remplacement ci-dessus corrompra les points de code non BMP en remplaçant parfois seulement la moitié de la paire de substitution. Il est possible que ce soit un bogue Java plutôt qu'un comportement prévu.

L'utilisation des autres catégories constituantes est une option:

myString.replaceAll("[\\p{Cc}\\p{Cf}\\p{Co}\\p{Cn}]", "?");

Cependant, les caractères de substitution solitaires ne faisant pas partie d'une paire (chaque caractère de substitution a un point de code attribué) ne seront pas supprimés. Une approche non-regex est le seul moyen que je connaisse pour gérer correctement \p{C}:

StringBuilder newString = new StringBuilder(myString.length());
for (int offset = 0; offset < myString.length();)
{
    int codePoint = myString.codePointAt(offset);
    offset += Character.charCount(codePoint);

    // Replace invisible control characters and unused code points
    switch (Character.getType(codePoint))
    {
        case Character.CONTROL:     // \p{Cc}
        case Character.FORMAT:      // \p{Cf}
        case Character.PRIVATE_USE: // \p{Co}
        case Character.SURROGATE:   // \p{Cs}
        case Character.UNASSIGNED:  // \p{Cn}
            newString.append('?');
            break;
        default:
            newString.append(Character.toChars(codePoint));
            break;
    }
}

Vous pourriez être intéressé par les catégories Unicode «Autre, Contrôle» et éventuellement «Autre, Format» (malheureusement, ce dernier semble contenir à la fois des caractères non imprimables et imprimables).

Dans les expressions régulières Java, vous pouvez les vérifier en utilisant respectivement \p{Cc}et \p{Cf}.

méthodes en coup pour votre objectif

public static String removeNonAscii(String str)
{
    return str.replaceAll("[^\\x00-\\x7F]", "");
}

public static String removeNonPrintable(String str) // All Control Char
{
    return str.replaceAll("[\\p{C}]", "");
}

public static String removeSomeControlChar(String str) // Some Control Char
{
    return str.replaceAll("[\\p{Cntrl}\\p{Cc}\\p{Cf}\\p{Co}\\p{Cn}]", "");
}

public static String removeFullControlChar(String str)
{
    return removeNonPrintable(str).replaceAll("[\\r\\n\\t]", "");
} 

J'ai utilisé cette fonction simple pour cela:

private static Pattern pattern = Pattern.compile("[^ -~]");
private static String cleanTheText(String text) {
    Matcher matcher = pattern.matcher(text);
    if ( matcher.find() ) {
        text = text.replace(matcher.group(0), "");
    }
    return text;
}

J'espère que c'est utile.

Sur la base des réponses de l' Op De Cirkel et de noackjr , voici ce que je fais pour le nettoyage général des chaînes: 1. rognage des espaces de début ou de fin, 2. dos2unix, 3. mac2unix, 4. suppression de tous les "caractères Unicode invisibles" sauf les espaces:

myString.trim.replaceAll("\r\n", "\n").replaceAll("\r", "\n").replaceAll("[\\p{Cc}\\p{Cf}\\p{Co}\\p{Cn}&&[^\\s]]", "")

Testé avec Scala REPL.

Je propose de supprimer les caractères non imprimables comme ci-dessous au lieu de le remplacer

private String removeNonBMPCharacters(final String input) {
    StringBuilder strBuilder = new StringBuilder();
    input.codePoints().forEach((i) -> {
        if (Character.isSupplementaryCodePoint(i)) {
            strBuilder.append("?");
        } else {
            strBuilder.append(Character.toChars(i));
        }
    });
    return strBuilder.toString();
}

J'ai repensé le code pour les numéros de téléphone +9 (987) 124124 Extraire les chiffres d'une chaîne en Java

 public static String stripNonDigitsV2( CharSequence input ) {
    if (input == null)
        return null;
    if ( input.length() == 0 )
        return "";

    char[] result = new char[input.length()];
    int cursor = 0;
    CharBuffer buffer = CharBuffer.wrap( input );
    int i=0;
    while ( i< buffer.length()  ) { //buffer.hasRemaining()
        char chr = buffer.get(i);
        if (chr=='u'){
            i=i+5;
            chr=buffer.get(i);
        }

        if ( chr > 39 && chr < 58 )
            result[cursor++] = chr;
        i=i+1;
    }

    return new String( result, 0, cursor );
}