Каков правильный подход к конкатенации нулевой строки в Java?

Ответ 1

Самое краткое решение:

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

или, возможно, создать или использовать статический вспомогательный метод, чтобы сделать то же самое; например.

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

Однако этот вопрос имеет "запах" приложения, чрезмерное использование/неправильное использование null. Лучше использовать/возвращать null, если он имеет конкретное значение, которое отличается (и должно быть отличным) от значений ненулевых значений.

Например:

• Если эти нули поступают из атрибутов String, которые по умолчанию были инициализированы на null, рассмотрите явно их инициализацию вместо "".
• Не используйте null для обозначения пустых массивов или коллекций.
• Не возвращайте null, когда было бы лучше создать исключение.
• Рассмотрите возможность использования Нулевого шаблона объекта.

Теперь очевидно, что есть все контр-примеры, и иногда вам приходится иметь дело с ранее существовавшим API, который дает вам нули... по любой причине. Однако, по моему опыту, лучше избегать использования null... большую часть времени.

Итак, в вашем случае лучший подход может быть:

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

Ответ 2

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

Но то, что вы действительно просите, это нулевой оператор коалесценции.

Ответ 3

Вы можете использовать следующее с Java 8:

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());

дает

abc

Несколько замечаний:

• Вы можете напрямую преобразовать структуры данных (списки и т.д.) в Stream<String>.
• Вы также можете указать разделитель при объединении строк.

Ответ 4

Вы можете использовать метод Apache Commons StringUtils.defaultString(String), или вы даже можете написать свой собственный метод, который будет всего лишь одним лайнером, если вы не используете какой-либо третий партийной библиотеки.

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

а затем используйте его в своем sysout следующим образом:

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

Ответ 5

Вы можете объявить свой собственный метод для 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 "";
    }
}

Ответ 6

Попробуйте это

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

Строковая переменная (здесь, s) вызывается null, когда в переменной нет объектов. Поэтому инициализируйте variale пустой строкой, которая ""; Затем вы можете объединить строки.

Если ваша переменная s может быть нулевой или не нулевой, используйте условный оператор, прежде чем использовать его дальше. Тогда переменная s больше не равна нулю.

Это пример кода:

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

Пример вывода:

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

Ответ 7

Другой подход заключается в использовании java.util.Objects.toString(), который был добавлен в Java 7:

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

Это работает для любого объекта, а не только для строк, и, конечно, вы можете указать другое значение по умолчанию вместо пустой строки.

Ответ 8

На ум приходит два метода: первый не использует конкатенацию, но безопасен:

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

Второе использование конкатенации, но требует, чтобы ваша фактическая строка никогда не содержала "null", поэтому ее можно использовать только для очень простых случаев (во всяком случае, даже если строка никогда не является "нулевой", я бы никогда ее не использовал):

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

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

ПРИМЕЧАНИЯ:

-Используйте метод внешней утилиты, так как я против вложения множества условных обозначений.

-Это не проверено, и я могу запутать синтаксис С# с Java