Überprüfen Sie, ob der String nur Buchstaben enthält

Die Idee ist, einen String lesen zu lassen und zu überprüfen, ob er keine numerischen Zeichen enthält. So etwas wie "smith23" wäre also nicht akzeptabel.

Was willst du? Geschwindigkeit oder Einfachheit? Wählen Sie aus Gründen der Geschwindigkeit einen schleifenbasierten Ansatz. Wählen Sie der Einfachheit halber einen einzeiligen RegEx-basierten Ansatz.

Geschwindigkeit

public boolean isAlpha(String name) {
    char[] chars = name.toCharArray();

    for (char c : chars) {
        if(!Character.isLetter(c)) {
            return false;
        }
    }

    return true;
}

Einfachheit

public boolean isAlpha(String name) {
    return name.matches("[a-zA-Z]+");
}

Java 8 Lambda-Ausdrücke. Schnell und einfach.

boolean allLetters = someString.chars().allMatch(Character::isLetter);

Oder wenn Sie Apache Commons verwenden, [StringUtils.isAlpha ()] .

Erstes Importmuster:

import java.util.regex.Pattern;

Verwenden Sie dann diesen einfachen Code:

String s = "smith23";
if (Pattern.matches("[a-zA-Z]+",s)) { 
  // Do something
  System.out.println("Yes, string contains letters only");
}else{
  System.out.println("Nope, Other characters detected");    
}

Dies wird Folgendes ausgeben:

Nein, andere Zeichen erkannt

Ich habe diesen regulären Ausdruck verwendet (".*[a-zA-Z]+.*"). Mit if notAnweisung werden alle Ausdrücke vermieden, die vor, am Ende oder zwischen anderen Zeichen einen Buchstaben haben.

String strWithLetters = "123AZ456";
if(! Pattern.matches(".*[a-zA-Z]+.*", str1))
 return true;
else return false

Ein schneller Weg, dies zu tun, ist:

public boolean isStringAlpha(String aString) {
    int charCount = 0;
    String alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

    if (aString.length() == 0) {
        return false; //zero length string ain't alpha
    }

    for (int i = 0; i < aString.length(); i++) {
        for (int j = 0; j < alphabet.length(); j++) {
            if (aString.substring(i, i + 1).equals(alphabet.substring(j, j + 1))
                    || aString.substring(i, i + 1).equals(alphabet.substring(j, j + 1).toLowerCase())) {
                charCount++;
            }
        }

        if (charCount != (i + 1)) {
            System.out.println("\n**Invalid input! Enter alpha values**\n");
            return false;
        }
    }

    return true;
}

Weil Sie nicht das ganze ausführen müssen, um aStringzu überprüfen, ob es sich nicht um einen Alpha-String handelt .

private boolean isOnlyLetters(String s){
    char c=' ';
    boolean isGood=false, safe=isGood;
    int failCount=0;
    for(int i=0;i<s.length();i++){
        c = s.charAt(i);
        if(Character.isLetter(c))
            isGood=true;
        else{
            isGood=false;
            failCount+=1;
        }
    }
    if(failCount==0 && s.length()>0)
        safe=true;
    else
        safe=false;
    return safe;
}

Ich weiß, dass es ein bisschen voll ist. Ich habe es mit meinem Programm verwendet und hatte den Wunsch, es mit anderen zu teilen. Es kann erkennen, ob ein Zeichen in einer Zeichenfolge kein Buchstabe ist oder nicht. Verwenden Sie es, wenn Sie etwas leicht zu klären und zurückblicken möchten.

Schnellerer Weg ist unten. In Anbetracht der Buchstaben sind nur az, AZ.

public static void main( String[] args ){ 
        System.out.println(bestWay("azAZpratiyushkumarsinghjdnfkjsaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"));
        System.out.println(isAlpha("azAZpratiyushkumarsinghjdnfkjsaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"));

        System.out.println(bestWay("azAZpratiyushkumarsinghjdnfkjsaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"));
        System.out.println(isAlpha("azAZpratiyushkumarsinghjdnfkjsaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"));
    }

    public static boolean bettertWay(String name) {
        char[] chars = name.toCharArray();
        long startTimeOne = System.nanoTime();
        for(char c : chars){
            if(!(c>=65 && c<=90)&&!(c>=97 && c<=122) ){
                System.out.println(System.nanoTime() - startTimeOne);
                    return false;
            }
        }
        System.out.println(System.nanoTime() - startTimeOne);
        return true;
    }


    public static boolean isAlpha(String name) {
        char[] chars = name.toCharArray();
        long startTimeOne = System.nanoTime();
        for (char c : chars) {
            if(!Character.isLetter(c)) {
                System.out.println(System.nanoTime() - startTimeOne);
                return false;
            }
        }
        System.out.println(System.nanoTime() - startTimeOne);
        return true;
    }

Die Laufzeit wird in Nanosekunden berechnet. Dies kann von System zu System variieren.

5748//bettertWay without numbers
true
89493 //isAlpha without  numbers
true
3284 //bettertWay with numbers
false
22989 //isAlpha with numbers
false

Überprüfen Sie dies, ich denke, dies ist eine Hilfe für Sie, da es in meinem Projekt funktioniert. Sobald Sie diesen Code überprüft haben

if(! Pattern.matches(".*[a-zA-Z]+.*[a-zA-Z]", str1))
 {
   String not contain only character;
 }
else 
{
  String contain only character;
}

        String expression = "^[a-zA-Z]*$";
        CharSequence inputStr = str;
        Pattern pattern = Pattern.compile(expression);
        Matcher matcher = pattern.matcher(inputStr);
        if(matcher.matches())
        {
              //if pattern matches 
        }
        else
        {
             //if pattern does not matches
        }

Versuchen Sie es mit regulären Ausdrücken: String.matches

public boolean isAlpha(String name)
{
    String s=name.toLowerCase();
    for(int i=0; i<s.length();i++)
    {
        if((s.charAt(i)>='a' && s.charAt(i)<='z'))
        {
            continue;
        }
        else
        {
           return false;
        }
    }
    return true;
}

Verwenden Sie die StringUtils.isAlpha () -Methode, um Ihr Leben zu vereinfachen.