¿Cómo puedo verificar si una cadena no es nula y no está vacía?

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

¿Qué pasa con isEmpty () ?

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

Asegúrese de usar las partes de &&en este orden, ya que Java no procederá a evaluar la segunda parte si la primera parte &&falla, asegurando así que no obtendrá una excepción de puntero nulo de str.isEmpty()si stres nulo.

Cuidado, solo está disponible desde Java SE 1.6. Tienes que consultar str.length() == 0las versiones anteriores.

Para ignorar también los espacios en blanco:

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

(ya que Java 11 str.trim().isEmpty()puede reducirse, str.isBlank()lo que también probará otros espacios en blanco Unicode)

Envuelto en una práctica función:

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

Se convierte en:

if( !empty( str ) )

Use org.apache.commons.lang.StringUtils

Me gusta usar Apache commons-lang para este tipo de cosas, y especialmente la clase de utilidad StringUtils :

import org.apache.commons.lang.StringUtils;

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

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

Solo agrego Android aquí:

import android.text.TextUtils;

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

Para agregar a @BJorn y @SeanPatrickFloyd La forma en que Guava hace esto es:

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

Commons Lang es más legible a veces, pero poco a poco he estado confiando más en la guayaba y, a veces, Commons Lang es confuso cuando se trata de isBlank()(como en el espacio en blanco o no).

La versión de Guava de Commons Lang isBlanksería:

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

Diré que el código que no permite ""(vacío) Y null es sospechoso y potencialmente defectuoso, ya que probablemente no maneja todos los casos en los que no está permitido tener nullsentido (aunque para SQL puedo entender que SQL / HQL es extraño '').

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

alternativamente

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

o

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

Nota: La segunda verificación (primera y segunda alternativa) asume que str no es nulo. ¡Está bien solo porque la primera verificación está haciendo eso (y Java no hace la segunda verificación si la primera es falsa)!

IMPORTANTE: NO use == para la igualdad de cadena. == comprueba que el puntero es igual, no el valor. ¡Dos cadenas pueden estar en diferentes direcciones de memoria (dos instancias) pero tienen el mismo valor!

Casi todas las bibliotecas que conozco definen una clase de utilidad llamada StringUtils, StringUtilo StringHelper, y generalmente incluyen el método que está buscando.

Mi favorito personal es Apache Commons / Lang , donde en la clase StringUtils , obtienes ambos

(La primera verifica si una cadena es nula o vacía, la segunda verifica si es nula, vacía o solo en blanco)

Hay clases de utilidad similares en Spring, Wicket y muchas otras bibliotecas. Si no usa bibliotecas externas, es posible que desee introducir una clase StringUtils en su propio proyecto.

Actualización: han pasado muchos años, y en estos días recomendaría usar el método de GuavaStrings.isNullOrEmpty(string) .

Esto funciona para mi:

import com.google.common.base.Strings;

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

Devuelve verdadero si la cadena dada es nula o es la cadena vacía.

Considere normalizar sus referencias de cadena con nullToEmpty. Si lo hace, puede usar String.isEmpty () en lugar de este método, y tampoco necesitará formas especiales de métodos nulos seguros como String.toUpperCase. O, si desea normalizar "en la otra dirección", convirtiendo cadenas vacías a nulas, puede usar emptyToNull.

Qué tal si:

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

Utilice el método isNotBlank de Apache StringUtils como

StringUtils.isNotBlank(str)

Volverá verdadero solo si el str no es nulo y no está vacío.

Deberías usar org.apache.commons.lang3.StringUtils.isNotBlank()o org.apache.commons.lang3.StringUtils.isNotEmpty. La decisión entre estos dos se basa en lo que realmente desea verificar.

Los isNotBlank () comprueba que el parámetro de entrada es:

• no nulo,
• no la cadena vacía ("")
• no es una secuencia de espacios en blanco ("")

El isNotEmpty () comprueba sólo que el parámetro de entrada es

• no nulo
• no la cadena vacía ("")

Devuelve verdadero o falso según la entrada

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

Si no desea incluir toda la biblioteca; solo incluye el código que quieras de él. Tendrás que mantenerlo tú mismo; pero es una función bastante sencilla. Aquí se copia de 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;
}

Es un poco tarde, pero aquí hay un estilo funcional de verificación:

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

Hay un nuevo método en java-11: String#isBlank

Devuelve verdadero si la cadena está vacía o contiene solo puntos de código de espacio en blanco, de lo contrario es falso.

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

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

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

Esto podría combinarse Optionalpara verificar si la cadena es nula o está vacía

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

Cadena # isBlank

prueba es igual a una cadena vacía y nula en el mismo condicional:

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

No lanza NullPointerExceptionsi str es nulo, ya que Object.equals()devuelve falso si arg es null.

la otra construcción str.equals("")arrojaría lo temido NullPointerException. Algunos podrían considerar una forma incorrecta usando un literal de cadena como el objeto sobre el cual equals()se llama pero hace el trabajo.

Compruebe también esta respuesta: https://stackoverflow.com/a/531825/1532705

Solución simple :

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

Como Seanizer dijo anteriormente, Apache StringUtils es fantástico para esto, si incluyeses guayaba deberías hacer lo siguiente;

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

¿Puedo recomendar también que consulte las columnas en su conjunto de resultados por nombre en lugar de por índice, esto hará que su código sea mucho más fácil de mantener.

Hice mi propia función de utilidad para verificar varias cadenas a la vez, en lugar de tener una instrucción if llena de if(str != null && !str.isEmpty && str2 != null && !str2.isEmpty). Esta es la función:

public class StringUtils{

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

        return true;
    }   

}

así que simplemente puedo escribir:

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

En caso de que esté utilizando Java 8 y desee tener un enfoque de Programación más funcional, puede definir uno Functionque administre el control y luego puede reutilizarlo y apply()cuando sea necesario.

Al practicar, puedes definir Functioncomo

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

Luego, puede usarlo simplemente llamando al apply()método como:

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

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

Si lo prefiere, puede definir un Functionque compruebe si Stringestá vacío y luego negarlo !.

En este caso, Functionse verá así:

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

Luego, puede usarlo simplemente llamando al apply()método como:

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

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

Con Java 8 Opcional puedes hacer:

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

En esta expresión, manejarás Strings que también consisten en espacios.

Puede usar StringUtils.isEmpty (), resultará verdadero si la cadena es nula o vacía.

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

resultará en

str1 es nulo o está vacío

str2 es nulo o está vacío

Aconsejaría a Guava o Apache Commons según su necesidad real. Verifique los diferentes comportamientos en mi código de ejemplo:

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

Resultado:
Apache:
a está en blanco
b está en blanco
c está en blanco
Google:
b es NullOrEmpty
c es NullOrEmpty

Si está utilizando Spring Boot, el siguiente código hará el trabajo

StringUtils.hasLength(str)

Para completar: si ya está utilizando Spring Framework , StringUtils proporciona el método

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

Devuelve: verdadero si la cadena no es nula y tiene longitud

así como el método

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

Devuelve: verdadero si la cadena no es nula, su longitud es mayor que 0 y no contiene solo espacios en blanco

Simplemente, para ignorar el espacio en blanco también:

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

Si usa Spring Framework, puede usar el método:

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

Este método acepta cualquier objeto como argumento, comparándolo con una cadena nula y vacía. Como consecuencia, este método nunca devolverá verdadero para un objeto no String no nulo.

La mejor manera de manejar nulo en la cadena es,

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

En breve,

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

Para verificar si todos los atributos de cadena en un objeto están vacíos (en lugar de usar! = Nulo en todos los nombres de campo siguiendo el enfoque de la API de reflexión de Java

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

Este método devolvería verdadero si todos los valores del campo String están en blanco, devolvería falso si alguno de los valores está presente en los atributos String

Me he encontrado con una situación en la que debo comprobar que "nulo" (como una cadena) debe considerarse vacío. También el espacio en blanco y un nulo real deben devolver verdadero. Finalmente me decidí por la siguiente función ...

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

En caso de que necesite validar los parámetros de su método, puede usar el método simple siguiente

public class StringUtils {

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

}

Ejemplo:

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