Comment vérifier si une chaîne ne contient que de l'ASCII?

L'appel Character.isLetter(c)revient truesi le caractère est une lettre. Mais y a-t-il un moyen de trouver rapidement si a Stringne contient que les caractères de base de l'ASCII?

À partir de Guava 19.0, vous pouvez utiliser:

boolean isAscii = CharMatcher.ascii().matchesAllOf(someString);

Cela utilise la matchesAllOf(someString)méthode qui repose sur la méthode de fabrique ascii()plutôt que sur le ASCIIsingleton désormais obsolète .

Ici ASCII inclut tous les caractères ASCII y compris les caractères non imprimables inférieurs à 0x20(espace) tels que les tabulations, le saut de ligne / retour mais aussi BELavec code 0x07et DELavec code 0x7F.

Ce code utilise de manière incorrecte des caractères plutôt que des points de code, même si des points de code sont indiqués dans les commentaires des versions antérieures. Heureusement, les caractères requis pour créer un point de code avec une valeur de U+010000ou plus utilisent deux caractères de substitution avec une valeur en dehors de la plage ASCII. Ainsi, la méthode réussit toujours à tester l'ASCII, même pour les chaînes contenant des emoji.

Pour les versions antérieures de Guava sans la ascii()méthode, vous pouvez écrire:

boolean isAscii = CharMatcher.ASCII.matchesAllOf(someString);

Vous pouvez le faire avec java.nio.charset.Charset .

import java.nio.charset.Charset;

public class StringUtils {

  public static boolean isPureAscii(String v) {
    return Charset.forName("US-ASCII").newEncoder().canEncode(v);
    // or "ISO-8859-1" for ISO Latin 1
    // or StandardCharsets.US_ASCII with JDK1.7+
  }

  public static void main (String args[])
    throws Exception {

     String test = "Réal";
     System.out.println(test + " isPureAscii() : " + StringUtils.isPureAscii(test));
     test = "Real";
     System.out.println(test + " isPureAscii() : " + StringUtils.isPureAscii(test));

     /*
      * output :
      *   Réal isPureAscii() : false
      *   Real isPureAscii() : true
      */
  }
}

Détecter les caractères non ASCII dans une chaîne

Voici une autre façon de ne pas dépendre d'une bibliothèque mais d'utiliser une regex.

Vous pouvez utiliser cette seule ligne:

text.matches("\\A\\p{ASCII}*\\z")

Exemple de programme complet:

public class Main {
    public static void main(String[] args) {
        char nonAscii = 0x00FF;
        String asciiText = "Hello";
        String nonAsciiText = "Buy: " + nonAscii;
        System.out.println(asciiText.matches("\\A\\p{ASCII}*\\z"));
        System.out.println(nonAsciiText.matches("\\A\\p{ASCII}*\\z"));
    }
}

Parcourez la chaîne et assurez-vous que tous les caractères ont une valeur inférieure à 128.

Les chaînes Java sont codées conceptuellement en UTF-16. En UTF-16, le jeu de caractères ASCII est codé comme les valeurs 0 à 127 et le codage de tout caractère non ASCII (qui peut être composé de plus d'un caractère Java) est garanti de ne pas inclure les nombres 0 à 127

Ou vous copiez le code de la classe IDN .

// to check if a string only contains US-ASCII code point
//
private static boolean isAllASCII(String input) {
    boolean isASCII = true;
    for (int i = 0; i < input.length(); i++) {
        int c = input.charAt(i);
        if (c > 0x7F) {
            isASCII = false;
            break;
        }
    }
    return isASCII;
}

commons-lang3 d'Apache contient de précieuses méthodes utilitaires / pratiques pour toutes sortes de «problèmes», y compris celui-ci.

System.out.println(StringUtils.isAsciiPrintable("!@£$%^&!@£$%^"));

essaye ça:

for (char c: string.toCharArray()){
  if (((int)c)>127){
    return false;
  } 
}
return true;

Parcourez la chaîne et utilisez charAt () pour obtenir le char. Traitez-le ensuite comme un entier et voyez s'il a une valeur unicode (un sur-ensemble d'ASCII) que vous aimez.

Pause au début que vous n'aimez pas.

private static boolean isASCII(String s) 
{
    for (int i = 0; i < s.length(); i++) 
        if (s.charAt(i) > 127) 
            return false;
    return true;
}

C'était possible. Joli problème.

import java.io.UnsupportedEncodingException;
import java.nio.charset.Charset;
import java.nio.charset.CharsetEncoder;

public class EncodingTest {

    static CharsetEncoder asciiEncoder = Charset.forName("US-ASCII")
            .newEncoder();

    public static void main(String[] args) {

        String testStr = "¤EÀsÆW°ê»Ú®i¶T¤¤¤ß3¼Ó®i¶TÆU2~~KITEC 3/F Rotunda 2";
        String[] strArr = testStr.split("~~", 2);
        int count = 0;
        boolean encodeFlag = false;

        do {
            encodeFlag = asciiEncoderTest(strArr[count]);
            System.out.println(encodeFlag);
            count++;
        } while (count < strArr.length);
    }

    public static boolean asciiEncoderTest(String test) {
        boolean encodeFlag = false;
        try {
            encodeFlag = asciiEncoder.canEncode(new String(test
                    .getBytes("ISO8859_1"), "BIG5"));
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return encodeFlag;
    }
}

Cela renverra true si String ne contient que des caractères ASCII et false dans le cas contraire

Charset.forName("US-ASCII").newEncoder().canEncode(str)

Si vous souhaitez supprimer non ASCII, voici l'extrait de code:

if(!Charset.forName("US-ASCII").newEncoder().canEncode(str)) {
                        str = str.replaceAll("[^\\p{ASCII}]", "");
                    }

//return is uppercase or lowercase
public boolean isASCIILetter(char c) {
  return (c > 64 && c < 91) || (c > 96 && c < 123);
}