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

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

---

아이디어는 문자열을 읽고 숫자가 포함되어 있지 않은지 확인하는 것입니다. 따라서 "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 ()] .

---

이 정규식을 사용했습니다 (".*[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 이 아닌지 확인하기 위해 전체를 실행할 필요가 없기 때문입니다 .

---

첫 번째 가져 오기 패턴 :

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

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

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

---

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

---

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

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

---

        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 () 메서드를 사용하면 삶이 단순해질 것입니다.

---

Solution: I prefer to use a simple loop.

public static boolean isAlpha(String s) {
    if (s == null || s.length() == 0) {
        return false;
    }

    char[] chars = s.toCharArray();
    for (int index = 0; index < chars.length; index++) {
        int codePoint = Character.codePointAt(chars, index);
        if (!Character.isLetter(codePoint)) {
            return false;
        }
    }

    return true;
}

참고URL : https://stackoverflow.com/questions/5238491/check-if-string-contains-only-letters