문자열이 null이 아니고 비어 있지 않은지 어떻게 확인할 수 있습니까?

public void doStuff(String str)
{
    if (str != null && str != "**here I want to check the 'str' is empty or not**")
    {
        /* handle empty string */
    }
    /* ... */
}

무엇에 대한 IsEmpty 함수 () ?

if(str != null && !str.isEmpty())

&&java는 첫 번째 부분이 &&실패하면 두 번째 부분을 평가하지 않으므로이 부분을 순서대로 사용하십시오 . 따라서 str.isEmpty()if str가 null이면 널 포인터 예외가 발생하지 않습니다 .

Java SE 1.6 이후에만 사용할 수 있습니다. str.length() == 0이전 버전 을 확인해야합니다 .

공백도 무시하려면 :

if(str != null && !str.trim().isEmpty())

(Java 11 str.trim().isEmpty()은 str.isBlank()다른 유니 코드 공백도 테스트 하도록 축소 될 수 있기 때문에 )

편리한 기능에 싸여 있습니다 :

public static boolean empty( final String s ) {
  // Null-safe, short-circuit evaluation.
  return s == null || s.trim().isEmpty();
}

된다 :

if( !empty( str ) )

org.apache.commons.lang.StringUtils 사용

이런 종류의 것들, 특히 StringUtils 유틸리티 클래스에 Apache commons-lang 을 사용하고 싶습니다 .

import org.apache.commons.lang.StringUtils;

if (StringUtils.isNotBlank(str)) {
    ...
} 

if (StringUtils.isBlank(str)) {
    ...
} 

여기에 Android를 추가하면됩니다.

import android.text.TextUtils;

if (!TextUtils.isEmpty(str)) {
...
}

@BJorn 및 @SeanPatrickFloyd에 추가하려면 구아바 방법은 다음과 같습니다.

Strings.nullToEmpty(str).isEmpty(); 
// or
Strings.isNullOrEmpty(str);

Commons Lang은 때때로 더 읽기 쉬워졌지만 천천히 Guava에 더 많이 의존하고 있으며 Commons Lang isBlank()은 공백이 무엇인지와 같이 혼란 스러울 수 있습니다.

구아바의 Commons Lang 버전 isBlank은 다음과 같습니다.

Strings.nullToEmpty(str).trim().isEmpty()

나는 말할 것이다 허용하지 않는 코드 ""(빈) 과 null 의심과 아마 허용하지 않습니다 모든 경우에 처리하지 않는 잠재적 버그가 null차종 감각 (SQL / HQL 이상한 약으로 SQL 내가 이해할 수에 대한 있지만 '').

str != null && str.length() != 0

대안 적으로

str != null && !str.equals("")

또는

str != null && !"".equals(str)

참고 : 두 번째 검사 (첫 번째 및 두 번째 대안)는 str이 null이 아니라고 가정합니다. 첫 번째 검사가 그렇게하기 때문에 괜찮습니다 (첫 번째 검사가 거짓이면 Java는 두 번째 검사를 수행하지 않습니다)!

중요 : 문자열 동등성을 위해 ==를 사용하지 마십시오. == 포인터가 값이 아닌 동일한 지 확인합니다. 두 개의 문자열은 다른 메모리 주소 (두 인스턴스)에있을 수 있지만 동일한 값을 갖습니다!

거의 모든 라이브러리 나는 정의를라는 유틸리티 클래스를 알고 StringUtils, StringUtil또는 StringHelper, 그들은 일반적으로 당신이 찾고있는 방법을들 수있다.

내 개인적인 마음에 드는는 아파치 코 몬즈 / 랭 에, StringUtils에의 클래스, 당신이 얻을 모두

(첫 번째는 문자열이 null인지 비어 있는지 확인하고, 두 번째는 문자열이 null인지, 비어 있는지 또는 공백인지 확인합니다.)

Spring, Wicket 및 기타 많은 라이브러리에 유사한 유틸리티 클래스가 있습니다. 외부 라이브러리를 사용하지 않는 경우 자신의 프로젝트에 StringUtils 클래스를 도입 할 수 있습니다.

업데이트 : 몇 년이 지났으며 요즘에는 Guava 의 Strings.isNullOrEmpty(string)방법을 사용하는 것이 좋습니다 .

이것은 나를 위해 작동합니다 :

import com.google.common.base.Strings;

if (!Strings.isNullOrEmpty(myString)) {
       return myString;
}

주어진 문자열이 null이거나 빈 문자열이면 true를 반환합니다.

nullToEmpty로 문자열 참조를 정규화하는 것을 고려하십시오. 그렇게하면이 메서드 대신 String.isEmpty ()를 사용할 수 있으며 String.toUpperCase와 같은 특수한 null 안전 형식의 메서드도 필요하지 않습니다. 또는 빈 문자열을 null로 변환하여 "다른 방향으로"정규화하려면 emptyToNull을 사용할 수 있습니다.

어때요?

if(str!= null && str.length() != 0 )

Apache StringUtils의 isNotBlank 메소드를 사용하십시오.

StringUtils.isNotBlank(str)

str이 null이 아니고 비어 있지 않은 경우에만 true를 반환합니다.

당신은 사용해야 org.apache.commons.lang3.StringUtils.isNotBlank()하거나 org.apache.commons.lang3.StringUtils.isNotEmpty. 이 두 가지의 결정은 실제로 확인하려는 내용을 기반으로합니다.

isNotBlank () 는 입력 변수가 있음을 확인 :

• 널이 아니라
• 빈 문자열이 아님 ( "")
• 일련의 공백 문자 ( "")가 아님

isNotEmpty () 는 입력 파라미터 인 것을 확인 만

• null이 아님
• 빈 문자열이 아님 ( "")

입력에 따라 true 또는 false를 반환합니다.

Predicate<String> p = (s)-> ( s != null && !s.isEmpty());
p.test(string);

전체 라이브러리를 포함하지 않으려면 원하는 코드 만 포함하면됩니다. 직접 관리해야합니다. 그러나 그것은 매우 직설적 인 기능입니다. 여기에서 commons.apache.org 에서 복사

    /**
 * <p>Checks if a String is whitespace, empty ("") or null.</p>
 *
 * <pre>
 * StringUtils.isBlank(null)      = true
 * StringUtils.isBlank("")        = true
 * StringUtils.isBlank(" ")       = true
 * StringUtils.isBlank("bob")     = false
 * StringUtils.isBlank("  bob  ") = false
 * </pre>
 *
 * @param str  the String to check, may be null
 * @return <code>true</code> if the String is null, empty or whitespace
 * @since 2.0
 */
public static boolean isBlank(String str) {
    int strLen;
    if (str == null || (strLen = str.length()) == 0) {
        return true;
    }
    for (int i = 0; i < strLen; i++) {
        if ((Character.isWhitespace(str.charAt(i)) == false)) {
            return false;
        }
    }
    return true;
}

너무 늦었지만 다음은 기능적 스타일 검사입니다.

Optional.ofNullable(str)
    .filter(s -> !(s.trim().isEmpty()))
    .ifPresent(result -> {
       // your query setup goes here
    });

새로운 방법이 있습니다 자바 -11: String#isBlank

문자열이 비어 있거나 공백 코드 포인트 만 포함하면 true를, 그렇지 않으면 false를 반환합니다.

jshell> "".isBlank()
$7 ==> true

jshell> " ".isBlank()
$8 ==> true

jshell> " ! ".isBlank()
$9 ==> false

이것은 Optional문자열이 null인지 또는 비어 있는지 확인하기 위해 결합 될 수 있습니다

boolean isNullOrEmpty = Optional.ofNullable(str).map(String::isBlank).orElse(true);

문자열 #isBlank

테스트는 빈 문자열과 같으며 동일한 조건부에서 null입니다.

if(!"".equals(str) && str != null) {
    // do stuff.
}

arg가 인 경우 false를 리턴 NullPointerException하므로 str이 널인 경우 발생 하지 않습니다 .Object.equals()null

다른 구조 str.equals("")는 두려운 것을 던질 것 NullPointerException입니다. 일부는 String 리터럴을 객체로 사용하여 잘못된 형식을 고려할 수 있습니다.equals() 가 호출 있지만 작업을 수행합니다.

이 답변을 확인하십시오 : https : //.com/a/531825/1532705

간단한 해결책 :

private boolean stringNotEmptyOrNull(String st) {
    return st != null && !st.isEmpty();
}

seanizer가 위에서 말했듯이 Apache StringUtils는 환상적입니다. 구아바를 포함하려면 다음을 수행해야합니다.

public List<Employee> findEmployees(String str, int dep) {
 Preconditions.checkState(StringUtils.isNotBlank(str), "Invalid input, input is blank or null");
 /** code here **/
}

또한 색인이 아닌 이름으로 결과 집합의 열을 참조하는 것이 좋습니다. 이렇게하면 코드를 훨씬 쉽게 유지 관리 할 수 ​​있습니다.

if 문으로 가득 찬 대신 여러 문자열을 한 번에 확인하는 자체 유틸리티 함수를 만들었습니다 if(str != null && !str.isEmpty && str2 != null && !str2.isEmpty). 이것은 기능입니다 :

public class StringUtils{

    public static boolean areSet(String... strings)
    {
        for(String s : strings)
            if(s == null || s.isEmpty)
                return false;

        return true;
    }   

}

그래서 간단히 쓸 수 있습니다 :

if(!StringUtils.areSet(firstName,lastName,address)
{
    //do something
}

Java 8을 사용 중이고보다 기능적인 프로그래밍 방식을 원할 경우 Function 경우 컨트롤을 관리하는 컨트롤을 다음 apply()필요할 때마다 재사용 할 수 있습니다 .

연습에오고, 당신은을 정의 할 수 있습니다 Function로

Function<String, Boolean> isNotEmpty = s -> s != null && !"".equals(s)

그런 다음 단순히 apply()메소드를 다음과 같이 호출하여 사용할 수 있습니다 .

String emptyString = "";
isNotEmpty.apply(emptyString); // this will return false

String notEmptyString = "StackOverflow";
isNotEmpty.apply(notEmptyString); // this will return true

원하는 Function경우 String가 비어 있는지 확인한 다음! .

이 경우의 Function모양은 다음과 같습니다.

Function<String, Boolean> isEmpty = s -> s == null || "".equals(s)

그런 다음 단순히 apply()메소드를 다음과 같이 호출하여 사용할 수 있습니다 .

String emptyString = "";
!isEmpty.apply(emptyString); // this will return false

String notEmptyString = "StackOverflow";
!isEmpty.apply(notEmptyString); // this will return true

함께 자바 8 옵션 당신은 할 수 있습니다 :

public Boolean isStringCorrect(String str) {
    return Optional.ofNullable(str)
            .map(String::trim)
            .map(string -> !str.isEmpty())
            .orElse(false);
}

이 표현식에서는 String공백으로 구성된을 처리 합니다.

StringUtils.isEmpty ()를 사용할 수 있습니다. 문자열이 null이거나 비어 있으면 true가됩니다.

 String str1 = "";
 String str2 = null;

 if(StringUtils.isEmpty(str)){
     System.out.println("str1 is null or empty");
 }

 if(StringUtils.isEmpty(str2)){
     System.out.println("str2 is null or empty");
 }

결과

str1이 null이거나 비어 있습니다

str2가 null이거나 비어 있습니다

나는 실제 필요에 따라 Guava 또는 Apache Commons에 조언 할 것입니다. 예제 코드에서 다른 동작을 확인하십시오.

import com.google.common.base.Strings;
import org.apache.commons.lang.StringUtils;

/**
 * Created by hu0983 on 2016.01.13..
 */
public class StringNotEmptyTesting {
  public static void main(String[] args){
        String a = "  ";
        String b = "";
        String c=null;

    System.out.println("Apache:");
    if(!StringUtils.isNotBlank(a)){
        System.out.println(" a is blank");
    }
    if(!StringUtils.isNotBlank(b)){
        System.out.println(" b is blank");
    }
    if(!StringUtils.isNotBlank(c)){
        System.out.println(" c is blank");
    }
    System.out.println("Google:");

    if(Strings.isNullOrEmpty(Strings.emptyToNull(a))){
        System.out.println(" a is NullOrEmpty");
    }
    if(Strings.isNullOrEmpty(b)){
        System.out.println(" b is NullOrEmpty");
    }
    if(Strings.isNullOrEmpty(c)){
        System.out.println(" c is NullOrEmpty");
    }
  }
}

결과 :
Apache :
a는 비어 있음
b는 비어 있음
c는 비어 있음
Google :
b는 NullOrEmpty
c는 NullOrEmpty

Spring Boot를 사용하는 경우 아래 코드가 작업을 수행합니다.

StringUtils.hasLength(str)

완전성의 경우 :이 경우 이미 스프링 프레임 워크를 사용 의 StringUtils에는 제공하는 방법을

org.springframework.util.StringUtils.hasLength(String str)

문자열이 null이 아니고 길이가있는 경우 true

방법뿐만 아니라

org.springframework.util.StringUtils.hasText(String str)

문자열이 null이 아니고 길이가 0보다 크고 공백 만 포함하지 않는 경우 true

공백을 무시하기 만하면됩니다.

if (str == null || str.trim().length() == 0) {
    // str is empty
} else {
    // str is not empty
}

Spring 프레임 워크를 사용하는 경우 메소드를 사용할 수 있습니다.

org.springframework.util.StringUtils.isEmpty(@Nullable Object str);

이 메소드는 모든 Object를 인수로 허용하며이를 널 및 빈 문자열과 비교합니다. 결과적으로이 메소드는 널이 아닌 비 문자열 오브젝트에 대해서는 true를 리턴하지 않습니다.

문자열에서 null을 처리하는 더 좋은 방법은

str!=null && !str.equalsIgnoreCase("null") && !str.isEmpty()

요컨대

str.length()>0 && !str.equalsIgnoreCase("null")

객체의 모든 문자열 속성이 비어 있는지 확인하려면 (Java 리플렉션 API 접근법에 따라 모든 필드 이름에서! = null을 사용하는 대신)

private String name1;
private String name2;
private String name3;

public boolean isEmpty()  {

    for (Field field : this.getClass().getDeclaredFields()) {
        try {
            field.setAccessible(true);
            if (field.get(this) != null) {
                return false;
            }
        } catch (Exception e) {
            System.out.println("Exception occurred in processing");
        }
    }
    return true;
}

이 메소드는 모든 String 필드 값이 비어 있으면 true를 리턴하고, String 속성에 하나의 값이 존재하면 false를 리턴합니다.

"null"(문자열)이 비어있는 것으로 간주되어야하는 상황이 발생했습니다. 또한 공백과 실제 널 은 true를 리턴해야합니다. 마침내 다음 기능을 결정했습니다 ...

public boolean isEmpty(String testString) {
  return ((null==testString) || "".equals((""+testString).trim()) || "null".equals((""+testString).toLowerCase()));
}

분석법 파라미터를 검증해야하는 경우 다음과 같은 간단한 분석법을 사용할 수 있습니다.

public class StringUtils {

    static boolean anyEmptyString(String ... strings) {
        return Stream.of(strings).anyMatch(s -> s == null || s.isEmpty());
    }

}

예:

public String concatenate(String firstName, String lastName) {
    if(StringUtils.anyBlankString(firstName, lastName)) {
        throw new IllegalArgumentException("Empty field found");
    }
    return firstName + " " + lastName;
}