문자열에 문자 만 포함되어 있는지 확인

아이디어는 문자열을 읽고 숫자가 포함되어 있지 않은지 확인하는 것입니다. 따라서 "smith23"과 같은 것은 허용되지 않습니다.

무엇을 원하십니까? 속도 또는 단순성? 속도를 위해 루프 기반 접근 방식을 선택하십시오. 단순성을 위해 단일 라이너 RegEx 기반 접근 방식을 선택하십시오.

속도

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

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

    return true;
}

간단

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

자바 8 람다 식. 빠르고 간단합니다.

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

또는 Apache Commons를 사용하는 경우 [StringUtils.isAlpha ()] .

첫 번째 가져 오기 패턴 :

import java.util.regex.Pattern;

그런 다음 다음 간단한 코드를 사용하십시오.

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

그러면 다음이 출력됩니다.

아니요, 다른 문자가 감지되었습니다.

이 정규식을 사용했습니다 (".*[a-zA-Z]+.*"). With if not문은 다른 문자의 앞, 끝 또는 사이에 문자가있는 모든 표현식을 피합니다.

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

빨리 그것을 할 수있는 방법입니다 :

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

알파 StringaString 이 아닌지 확인하기 위해 전체를 실행할 필요가 없기 때문입니다 .

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

조금 혼잡하다는 것을 알고 있습니다. 저는 제 프로그램과 함께 사용하고 있었고 사람들과 공유하고 싶다는 소망을 느꼈습니다. 문자열의 문자가 문자가 아닌지 알 수 있습니다. 쉽게 명확하게하고 되돌아보고 싶을 때 사용하세요.

더 빠른 방법은 다음과 같습니다. 문자가 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;
    }

런타임은 나노초 단위로 계산됩니다. 시스템마다 다를 수 있습니다.

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

이것을 확인하십시오. 내 프로젝트에서 작동하므로 도움이 될 것 같습니다.

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
        }

정규식을 사용해보십시오 : 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;
}

StringUtils.isAlpha () 메서드를 사용하면 삶이 단순해질 것입니다.