java - truco - como saber si es oro o chapa

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

Question

¿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 */
    }
    /* ... */
}

Answer 1

Utilice org.apache.commons.lang.StringUtils

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

import org.apache.commons.lang.StringUtils;

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

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

Answer 2

¿Qué pasa con isEmpty() ?

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

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

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

Para ignorar los espacios en blanco también:

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

(ya que Java 11 str.trim().isEmpty() se puede reducir a str.isBlank() que también probará otros espacios en blanco de Unicode)

Envuelto en una función práctica:

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

Se convierte en

if( !empty( str ) )

Answer 3

Aconsejaría a Guayaba o Apache Commons de acuerdo con su necesidad real. Compruebe 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

Answer 4

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

Mi favorito personal es commons-lang , donde en la clase StringUtils , obtienes tanto

1. StringUtils.isEmpty(String) y la
2. StringUtils.isBlank(String)

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

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

Answer 5

Como dijo el apoderado anteriormente, Apache StringUtils es fantástico para esto, si incluyes 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 **/
}

También puedo recomendar que haga referencia 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.

Answer 6

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 una String que también consta de espacios.

Answer 7

Debe 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 es:

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

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

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

Answer 8

Devuelve verdadero o falso basado en la entrada

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

Answer 9

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

Si viene a practicar, puede definir la Function como

Function<String, Boolean> 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 = "";
isNotEmpty.apply(notEmptyString); // this will return true

Si lo prefiere, puede definir una Function que verifique si la String está vacía y luego anularla con ! .

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

Function<String, Boolean> 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 = "";
!isEmpty.apply(notEmptyString); // this will return true

Answer 10

Es un poco demasiado 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
    });

Answer 11

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 cadena con nullToEmpty. Si lo hace, puede usar String.isEmpty () en lugar de este método, y tampoco necesitará formas especiales seguras nulas de métodos como String.toUpperCase. O, si desea normalizar "en la otra dirección", convirtiendo cadenas vacías a nulas, puede usar emptyToNull.

Answer 12

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

Devuelve verdadero si la cadena está vacía o solo contiene puntos de código de espacios 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

Answer 13

He creado mi propia función de utilidad para comprobar 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
}

Answer 14

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

Answer 15

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 confiado más en 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 isBlank 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 porque probablemente no maneja todos los casos en los que no es null tiene sentido (aunque para SQL puedo entenderlo como SQL / HQL raro sobre '''' ).

Answer 16

Para completar: si ya está utilizando el marco Spring , los StringUtils proporcionan 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

Answer 17

Puede usar StringUtils.isEmpty (), resultará 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 vacío

str2 es nulo o vacío

Answer 18

Qué tal si:

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

Answer 19

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

Answer 20

Si usas Spring Framework entonces puedes 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 devolverá verdadero para un objeto que no sea String que no sea nulo.

Answer 21

Simplemente añadiendo Android aquí:

import android.text.TextUtils;

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

Answer 22

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

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

Answer 23

Solución simple :

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

Answer 24

Utilice el método isNotBlank de Apache StringUtils ''como

StringUtils.isNotBlank(str)

Devolverá verdadero solo si la cadena no es nula y no está vacía.

Answer 25

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

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

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

la otra construcción str.equals("") lanzaría la temida NullPointerException . Algunos podrían considerar una forma incorrecta utilizando un literal de cadena como el objeto al que se llama equals() pero cumple su función.

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

Answer 26

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

alternativamente

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

o

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

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

IMPORTANTE: NO use == para la igualdad de cuerdas. == 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!