Como verificar se uma String contém apenas ASCII?

A chamada Character.isLetter(c)retorna truese o caractere for uma letra. Mas existe uma maneira de descobrir rapidamente se a Stringcontém apenas os caracteres básicos do ASCII?

De Guava 19.0 em diante, você pode usar:

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

Este usa o matchesAllOf(someString)método que depende do método de fábrica ascii()em vez do agora obsoletoASCII singleton .

Aqui, ASCII inclui todos os caracteres ASCII, incluindo os caracteres não imprimíveis abaixo de 0x20(espaço), como tabulações, alimentação de linha / retorno, mas também BELcom código 0x07e DELcom código 0x7F.

Esse código usa caracteres incorretamente em vez de pontos de código, mesmo se os pontos de código forem indicados nos comentários de versões anteriores. Felizmente, os caracteres necessários para criar o ponto de código com um valor igual U+010000ou superior a usam dois caracteres substitutos com um valor fora do intervalo ASCII. Portanto, o método ainda consegue testar o ASCII, mesmo para strings contendo emoji.

Para versões anteriores do Guava sem o ascii()método, você pode escrever:

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

Você pode fazer isso com 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
      */
  }
}

Detecta caracteres não ASCII em uma string

Aqui está outra maneira, não dependendo de uma biblioteca, mas usando um regex.

Você pode usar esta única linha:

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

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

Faça a iteração pela string e certifique-se de que todos os caracteres tenham um valor menor que 128.

Java Strings são conceitualmente codificados como UTF-16. Em UTF-16, o conjunto de caracteres ASCII é codificado como os valores 0 - 127 e a codificação para qualquer caractere não ASCII (que pode consistir em mais de um caractere Java) tem garantia de não incluir os números 0 - 127

Ou você copia o código da 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 do Apache contém métodos de utilidade / conveniência valiosos para todos os tipos de 'problemas', incluindo este.

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

tente isto:

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

Faça a iteração pela string e use charAt () para obter o char. Em seguida, trate-o como um int e veja se ele tem um valor unicode (um superconjunto de ASCII) de sua preferência.

Quebre no primeiro que você não gosta.

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

Foi possível. Belo 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;
    }
}

Retornará verdadeiro se String contiver apenas caracteres ASCII e falso quando não contiver

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

Se você deseja remover não ASCII, aqui está o 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);
}