Wie überprüfe ich, ob ein String nur ASCII enthält?

Der Anruf wird Character.isLetter(c)zurückgegeben, truewenn das Zeichen ein Buchstabe ist. Aber gibt es eine Möglichkeit, schnell herauszufinden, ob a Stringnur die Basiszeichen von ASCII enthält?

Ab Guava 19.0 können Sie Folgendes verwenden:

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

Hierbei wird die matchesAllOf(someString)Methode verwendet, die auf der Factory-Methode ascii()und nicht auf dem jetzt veralteten ASCIISingleton basiert.

Hier enthält ASCII alle ASCII-Zeichen, einschließlich der nicht druckbaren Zeichen, die kleiner als 0x20(Leerzeichen) sind, wie Tabulatoren, Zeilenvorschub / Rückgabe, aber auch BELmit Code 0x07und DELmit Code 0x7F.

Dieser Code verwendet fälschlicherweise Zeichen anstelle von Codepunkten, selbst wenn Codepunkte in den Kommentaren früherer Versionen angegeben sind. Glücklicherweise verwenden die Zeichen, die zum Erstellen eines Codepunkts mit einem Wert von U+010000oder über erforderlich sind, zwei Ersatzzeichen mit einem Wert außerhalb des ASCII-Bereichs. Daher gelingt es der Methode immer noch, auf ASCII zu testen, selbst auf Zeichenfolgen, die Emojis enthalten.

Für frühere Guava-Versionen ohne die ascii()Methode können Sie schreiben:

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

Sie können dies mit java.nio.charset.Charset tun .

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

Erkennen Sie Nicht-ASCII-Zeichen in einem String

Hier ist eine andere Möglichkeit, die nicht von einer Bibliothek abhängt, sondern einen regulären Ausdruck verwendet.

Sie können diese einzelne Zeile verwenden:

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

Ganzes Beispielprogramm:

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

Durchlaufen Sie die Zeichenfolge und stellen Sie sicher, dass alle Zeichen einen Wert von weniger als 128 haben.

Java-Strings werden konzeptionell als UTF-16 codiert. In UTF-16 wird der ASCII-Zeichensatz als die Werte 0 bis 127 codiert, und die Codierung für jedes Nicht-ASCII-Zeichen (das aus mehr als einem Java-Zeichen bestehen kann) enthält garantiert nicht die Zahlen 0 bis 127

Oder Sie kopieren den Code aus der IDN- Klasse.

// 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 von Apache enthält wertvolle Dienstprogramm- / Bequemlichkeitsmethoden für alle Arten von "Problemen", einschließlich dieser.

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

Versuche dies:

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

Durchlaufen Sie die Zeichenfolge und verwenden Sie charAt (), um das Zeichen abzurufen. Behandeln Sie es dann als int und prüfen Sie, ob es einen Unicode-Wert (eine Obermenge von ASCII) hat, den Sie mögen.

Pause beim ersten, den du nicht magst.

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

Es war möglich. Hübsches Problem.

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

Dies gibt true zurück, wenn String nur ASCII-Zeichen enthält, und false, wenn dies nicht der Fall ist

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

Wenn Sie Nicht-ASCII entfernen möchten, finden Sie hier das Snippet:

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