parte - ¿Cuál es el enfoque correcto para concatenar una Cadena nula en Java?

extraer una parte de una cadena en java

Question

Sé que lo siguiente:

String s = null;
System.out.println("s: " + s);

saldrá: s: null .

¿Cómo puedo hacer que salga solo s: ​

En mi caso, esto es importante ya que tengo que concatenar String desde 4 valores, s1, s2, s3, s4 , donde cada uno de estos valores puede tener o no valor null .

Estoy haciendo esta pregunta, ya que no quiero verificar cada combinación de s1 a s4 (es decir, verificar si estas variables son null ) o reemplazar "null" con una String empty al final, ya que creo que puede haber alguna mejores formas de hacerlo.

Answer 1

La solución más concisa es esta:

System.out.println("s: " + (s == null ? "" : s));

o tal vez crear o usar un método de ayuda estático para hacer lo mismo; p.ej

System.out.println("s: " + denull(s));

Sin embargo, esta pregunta tiene el "olor" de una aplicación que está usando en exceso / mal uso null . Es mejor usar / devolver un null si tiene un significado específico que es distinto (y debe ser distinto) de los significados de valores no nulos.

Por ejemplo:

• Si estos valores nulos provienen de atributos de cadena que se han inicializado por defecto a null , considere la posibilidad de inicializarlos explícitamente en "" .
• No use null para denotar arreglos o colecciones vacías.
• No devuelva null cuando sería mejor lanzar una excepción.
• Considere usar el Patrón de Objeto Nulo .

Ahora, obviamente, hay contraejemplos para todo esto y, a veces, tiene que lidiar con una API preexistente que le da nulos ... por el motivo que sea. Sin embargo, en mi experiencia, es mejor evitar la null ... la mayoría de las veces.

Entonces, en su caso, el mejor enfoque puede ser:

String s = "";  /* instead of null */
System.out.println("s: " + s);

Answer 2

Me vienen a la mente dos métodos, el primero no usa concatenación pero es el más seguro:

public static void substituteNullAndPrint(String format, String nullString, Object... params){
    String[] stringParams = new String[params.length()];
    for(int i=0; i<params.length(); i++){
        if(params[i] == null){
            stringParams[i] = nullString;
        }else{
            stringParams[i] = params[i].toSTring();
        }
    }

    String formattedString = String.format(format, stringParams);
    System.out.println(formattedString);
}

USAGE:
substituteNullAndPrint("s: %s,%s", "", s1, s2);

El segundo uso concatena pero requiere que su cadena actual nunca contenga "nulo", por lo que puede ser utilizable solo para casos muy simples (De todos modos, incluso si la cadena nunca es "nula", nunca la usaría):

public static void substituteNullAndPrint(String str){
    str.replace("null", "");
    System.out.println(str);
}

USAGE:
substituteNullAndPrint("s: " + s1);

NOTAS:

-Hago uso del método de utilidad externo ya que estoy en contra de incluir muchos condicionales.

- Esto no está probado y podría estar confundiendo la sintaxis de c # con Java

Answer 3

Otro enfoque es usar java.util.Objects.toString() que se agregó en Java 7:

String s = null;
System.out.println("s: " + Objects.toString(s, ""));

Esto funciona para cualquier objeto, no solo para cadenas, y por supuesto puede proporcionar otro valor predeterminado en lugar de solo la cadena vacía.

Answer 4

Prueba esto

String s = s == null ? "" : s;
System.out.println("s: " + s);

Una variable de cadena (aquí, s ) se llama null cuando no hay ningún objeto asignado a la variable. Inicialice la variante con una cadena vacía que es "" ; Entonces puedes concatenar cadenas.

Si su variable s puede ser nula o no nula, use el operador condicional antes de usarla más. Entonces la variable s no es nula más.

Este es un código de muestra:

    String s1 = "Some Not NULL Text 1 ";
    String s2 = null;
    String s3 = "Some Not NULL Text 2 ";

    s1 = s1 == null ? "" : s1;
    s2 = s2 == null ? "" : s2;
    s3 = s3 == null ? "" : s3;

    System.out.println("s: " + s1 + s2 + s3);

Muestra de salida:

s: Some Not NULL Text 1 Some Not NULL Text 2

Answer 5

Puede declarar su propio método para la concatenation :

public static String concat(String... s) 
{//Use varArgs to pass any number of arguments
    if (s!=null) {
       StringBuilder sb = new StringBuilder();
       for(int i=0; i<s.length; i++) {
          sb.append(s[i] == null ? "" : s[i]);
       }
       return sb.toString();
    }
    else {
        return "";
    }
}

Answer 6

Puede usar lo siguiente con Java 8:

String s = null;
System.out.println("s: " + (s != null ? s : ""));

da

String s1 = "a";
String s2 = null;
String s3 = "c";
String s4 = "d";
String concat = Stream.of(s1, s2, s3, s4)
        .filter(s -> s != null)
        .collect(Collectors.joining());

Algunas cosas a tener en cuenta:

• Puede convertir las estructuras de datos (listas, etc.) directamente en un Stream<String> .
• También puede dar un delimitador al unir las cadenas.

Answer 7

Puede utilizar el StringUtils.defaultString(String) Apache Commons StringUtils.defaultString(String) , o incluso puede escribir su propio método que sería solo un liner, si no está utilizando ninguna biblioteca de terceros.

private static String nullToEmptyString(String str) {
    return str == null ? "" : str;
}

y luego úsalo en tu sysout así:

System.out.println("s: " + nullToEmptyString(s));

Answer 8

abc

Pero lo que realmente está pidiendo es un operador nulo coalescente .