Compruebe si una cadena no es nula y no está vacía

¿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, porque java no procederá a evaluar la segunda parte si la primera parte de && falla, lo que garantiza que no obtendrá una excepción de puntero nulo de str.isEmpty() si str es nulo .

    Cuidado, solo está disponible desde Java SE 1.6. Debes verificar str.length() == 0 en versiones anteriores.


    Ignorar el espacio en blanco también:

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

    Envuelto en una función útil:

     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 utilizar 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 agregando Android aquí:

     import android.text.TextUtils; if (!TextUtils.isEmpty(str)) { ... } 

    Para agregar a @BJorn y @SeanPatrickFloyd, la forma de hacer esto en Guava es:

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

    Commons Lang es más legible a veces, pero he estado dependiendo cada vez más de Guava 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 isBlank serí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á permitiendo que el null tenga sentido (aunque para SQL lo puedo entender como SQL / HQL es raro sobre '' ).

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

    alternativamente

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

    o

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

    Nota: El segundo control (primera y segunda alternativa) asume que str no es nulo. Está bien solo porque el primer cheque está haciendo eso (¡y Java no hace el segundo chequeo si el primero es falso)!

    IMPORTANTE: NO use == para igualdad de cadenas. == verifica que el puntero sea igual, no el valor. Dos cadenas pueden estar en diferentes direcciones de memoria (dos instancias) pero tienen el mismo valor.

    Esto funciona para mí:

     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 la posibilidad de normalizar sus referencias de cadenas con nullToEmpty. Si lo haces, puedes usar String.isEmpty () en lugar de este método, y tampoco necesitarás formas de métodos nulos seguros como String.toUpperCase. O bien, si desea normalizar “en la otra dirección”, convirtiendo cadenas vacías en nulas, puede usar emptyToNull.

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

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

    1. StringUtils.isEmpty (String) y el
    2. StringUtils.isBlank (String) método

    (El primero comprueba si una cadena es nula o está vacía, la segunda comprueba si es nula, vacía o solo en blanco)

    Hay clases de utilidad similares en Spring, Wicket y muchas otras librerías. 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 recomiendo utilizar el método Strings.isNullOrEmpty(string) Guava .

    Qué tal si:

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

    Utilice el método de Apache StringUtils ‘isNotBlank como

     StringUtils.isNotBlank(str) 

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

    Si no quieres 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 directa. Aquí está copiado de commons.apache.org

      /** * 

    Checks if a String is whitespace, empty ("") or null.

    * *
     * StringUtils.isBlank(null) = true * StringUtils.isBlank("") = true * StringUtils.isBlank(" ") = true * StringUtils.isBlank("bob") = false * StringUtils.isBlank(" bob ") = false * 

    * * @param str the String to check, may be null * @return true 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; }

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

    IsNotBlank () comprueba que el parámetro de entrada sea:

    • no nulo,
    • no la cadena vacía (“”)
    • no una secuencia de caracteres en blanco (“”)

    IsNotEmpty () comprueba solo que el parámetro de entrada es

    • no nulo
    • no la cadena vacía (“”)

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

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

    Como dijo el semestre anterior, Apache StringUtils es fantástico para esto, si tuviera que incluir guayaba debería hacer lo siguiente;

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

    También puedo recomendar que se refiera a 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.

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

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

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

    el otro constructo str.equals("") lanzaría la temida NullPointerException . Algunos podrían considerar la mala forma usando un literal String como el objeto sobre el que se llama equals() pero hace el trabajo.

    También verifique esta respuesta: https://stackoverflow.com/a/531825/1532705

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

    entonces simplemente puedo escribir:

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

    Puede usar StringUtils.isEmpty (), dará como resultado verdadero si la cadena es nula o está 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 tu necesidad real. Comprueba 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

    Solución simple :

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

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

    Llegando a la práctica, puedes definir la Function como

     Function isNotEmpty = s -> s != null && !"".equals(s) 

    Luego, puede usarlo simplemente llamando al método apply() 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 una Function que compruebe si la String está vacía y luego la niegue ! .

    En este caso, la Function se verá así:

     Function isEmpty = s -> s == null || "".equals(s) 

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

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

    Devuelve verdadero o falso en función de la entrada

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

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

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

    Devuelve: verdadero si el String no es nulo y tiene longitud

    así como también el método

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

    Devuelve: verdadero si el String no es nulo, su longitud es mayor que 0, y no contiene espacios en blanco solamente

    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 entonces puede usar el método:

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

    Este método acepta cualquier Objeto como argumento, comparándolo con nulo y la Cadena vacía. Como consecuencia, este método nunca volverá a ser verdadero para un objeto que no sea nulo y que no sea String.

    Con Java 8 Optional 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á String que también consta de espacios.

    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 con Optional para verificar si la cadena es nula o está vacía

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

    String # isBlank

    La mejor manera de manejar null en la cadena es,

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

    En breve,

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