¿Cómo verificar si una cadena contiene solo ASCII?

La llamada Character.isLetter(c)regresa truesi el personaje es una letra. Pero, ¿hay alguna manera de encontrar rápidamente si a Stringsolo contiene los caracteres base de ASCII?

Desde Guava 19.0 en adelante, puede usar:

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

Esto utiliza el matchesAllOf(someString)método que se basa en el método de fábrica en ascii()lugar del ASCIIsingleton ahora obsoleto .

Aquí ASCII incluye todos los caracteres ASCII, incluidos los caracteres no imprimibles inferiores a 0x20(espacio) como tabulaciones, salto de línea / retorno, pero también BELcon código 0x07y DELcon código 0x7F.

Este código utiliza incorrectamente caracteres en lugar de puntos de código, incluso si los puntos de código se indican en los comentarios de versiones anteriores. Afortunadamente, los caracteres necesarios para crear un punto de código con un valor de U+010000o superior utilizan dos caracteres sustitutos con un valor fuera del rango ASCII. Entonces, el método aún tiene éxito en la prueba de ASCII, incluso para cadenas que contienen emoji.

Para versiones anteriores de Guava sin el ascii()método, puede escribir:

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

Puede hacerlo con 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
      */
  }
}

Detectar caracteres no ASCII en una cadena

Aquí hay otra forma que no depende de una biblioteca, sino que usa una expresión regular.

Puede utilizar esta única línea:

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

Programa de ejemplo completo:

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

Repita la cadena y asegúrese de que todos los caracteres tengan un valor menor que 128.

Las cadenas de Java están codificadas conceptualmente como UTF-16. En UTF-16, el conjunto de caracteres ASCII se codifica con los valores 0-127 y se garantiza que la codificación de cualquier carácter no ASCII (que puede constar de más de un carácter Java) no incluye los números 0-127.

O copia el código de la clase 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 de Apache contiene valiosos métodos de utilidad / conveniencia para todo tipo de "problemas", incluido este.

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

prueba esto:

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

Repita la cadena y use charAt () para obtener el char. Luego trátelo como un int y vea si tiene un valor Unicode (un superconjunto de ASCII) que le guste.

Rompe a la primera que no te guste.

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

Era posible. Bastante problema.

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

Esto devolverá verdadero si String solo contiene caracteres ASCII y falso cuando no los contiene

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

Si desea eliminar no ASCII, aquí está el fragmento:

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