Проверьте, не является ли строка null и не пустой
Как я могу проверить, не является ли строка null и не пустой?
public void doStuff(String str)
{
if (str != null && str != "**here I want to check the 'str' is empty or not**")
{
/* handle empty string */
}
/* ... */
}
26 ответов
насчет isEmpty () ?
if(str != null && !str.isEmpty())
обязательно используйте части &&
в этом порядке, потому что java не будет продолжать оценивать вторую часть, если первая часть &&
терпит неудачу, таким образом, гарантируя, что вы не получите исключение нулевого указателя от str.isEmpty()
если str
равно null.
остерегайтесь, он доступен только с Java SE 1.6. Вы должны проверить str.length() == 0
на предыдущих версиях.
игнорировать пробелы как хорошо:
if(str != null && !str.trim().isEmpty())
обернутый в удобной функции:
public static boolean empty( final String s ) {
// Null-safe, short-circuit evaluation.
return s == null || s.trim().isEmpty();
}
будет:
if( !empty( str ) )
использовать org.апаш.палата общин.ленг.StringUtils
мне нравится использовать Apache commons-lang для таких вещей, и особенно StringUtils утилиты > класс:
import org.apache.commons.lang.StringUtils;
if (StringUtils.isNotBlank(str)) {
...
}
if (StringUtils.isBlank(str)) {
...
}
чтобы добавить в @BJorn и @SeanPatrickFloyd способ гуавы сделать это:
Strings.nullToEmpty(str).isEmpty();
// or
Strings.isNullOrEmpty(str);
Commons Lang иногда более читаем, но я медленно полагался больше на Guava plus иногда Commons Lang сбивает с толку, когда дело доходит до isBlank()
(как в том, что является пробелом или нет).
версия гуавы Commons Lang isBlank
будет:
Strings.nullToEmpty(str).trim().isEmpty()
Я скажу код, который не позволяет ""
(пусто) и null
подозрительно и потенциально багги в том, что он, вероятно, не обрабатывает все случаи, когда не позволяет null
имеет смысл (хотя для SQL я могу понять, как SQL / HQL странно о ''
).
str != null && str.length() != 0
как вариант
str != null && !str.equals("")
или
str != null && !"".equals(str)
Примечание: вторая проверка (первая и вторая альтернативы) предполагает, что str не является нулевым. Это нормально только потому, что первая проверка делает это (и Java не делает вторую проверку, если первая ложная)!
важно: не используйте == для равенства строк. = = проверяет, что указатель равен, а не значение. Две строки могут быть в разных адресах памяти (два экземпляра), но имеют одинаковое значение!
это работает для меня:
import com.google.common.base.Strings;
if (!Strings.isNullOrEmpty(myString)) {
return myString;
}
возвращает true, если данная строка имеет значение null или является пустой строкой.
рекомендуется нормализовать строку ссылок с nullToEmpty. Если вы вы можете использовать строку.пустой() вместо этого метода, и вы не нужны специальные null-безопасные формы методов, таких как String.метод touppercase любой. Или, если вы хотите нормализовать "в другом направлении," преобразования пустой строки в null, вы можете использовать emptyToNull.
почти каждая библиотека, которую я знаю, определяет класс утилиты под названием StringUtils
, StringUtil
или StringHelper
, и они обычно включают метод, который вы ищете.
мой личный фаворит Apache Commons / Lang, где в StringUtils класс, вы получите как
(первый проверяет, является ли строка нулевой или пустой, второй проверяет, является ли она нулевой, пустой или только пробел)
есть аналогичные классы полезности весной, калитка и много других библиотек. Если вы не используете внешние библиотеки, вы можете ввести класс StringUtils в свой собственный проект.
обновление: прошло много лет, и в эти дни я бы рекомендовал использовать гуавы ' s Strings.isNullOrEmpty(string)
метод.
используйте метод isNotBlank Apache StringUtils, например
StringUtils.isNotBlank(str)
он вернет true только в том случае, если str не равен null и не пуст.
Если вы не хотите включать всю библиотеку; просто включите код, который вы хотите от него. Вам придется поддерживать его самостоятельно; но это довольно прямая функция. Вот он скопирован из 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;
}
вы должны использовать org.apache.commons.lang3.StringUtils.isNotBlank()
или org.apache.commons.lang3.StringUtils.isNotEmpty
. Решение между этими двумя основано на том, что вы действительно хотите проверить.
на isNotBlank () проверяет, что входной параметр:
- не Null,
- не пустая строка ("")
- не последовательность пробелов ("")
на isNotEmpty() проверяет только, что входной параметр
- не значение null
- не пустая строка ("")
немного поздно, но вот функциональный стиль проверки:
Optional.ofNullable(str)
.filter(s -> !(s.trim().isEmpty()))
.ifPresent(result -> {
// your query setup goes here
});
Как сказал seanizer выше, Apache StringUtils фантастичен для этого, если вы должны были включить гуаву, вы должны сделать следующее;
public List<Employee> findEmployees(String str, int dep) {
Preconditions.checkState(StringUtils.isNotBlank(str), "Invalid input, input is blank or null");
/** code here **/
}
могу ли я также рекомендовать вам ссылаться на столбцы в вашем результирующем наборе по имени, а не по индексу, это сделает ваш код намного проще в обслуживании.
test равно с пустой строкой и null в том же условном:
if(!"".equals(str) && str != null) {
// do stuff.
}
не бросает NullPointerException
если str равно null, так как Object.equals()
возвращает false, если arg null
.
другое строительство str.equals("")
бросил бы страшный NullPointerException
. Некоторые могут посчитать дурным тоном, используя строковый литерал в качестве объекта, на который equals()
называется, но он выполняет свою работу.
также проверьте этот ответ: https://stackoverflow.com/a/531825/1532705
Я сделал свою собственную функцию утилиты, чтобы проверить несколько строк сразу, а не иметь оператор if, полный if(str != null && !str.isEmpty && str2 != null && !str2.isEmpty)
. Это функция:
public class StringUtils{
public static boolean areSet(String... strings)
{
for(String s : strings)
if(s == null || s.isEmpty)
return false;
return true;
}
}
Так что я могу просто написать:
if(!StringUtils.areSet(firstName,lastName,address)
{
//do something
}
простое решение :
private boolean stringNotEmptyOrNull(String st) {
return st != null && !st.isEmpty();
}
возвращает true или false на основе input
Predicate<String> p = (s)-> ( s != null && !s.isEmpty());
p.test(string);
есть новый метод в java-11: String#isBlank
возвращает true, если строка пуста или содержит только пробелы, в противном случае false.
jshell> "".isBlank()
==> true
jshell> " ".isBlank()
==> true
jshell> " ! ".isBlank()
==> false
это может быть объединено с Optional
чтобы проверить, является ли строка null или пустой
boolean isNullOrEmpty = Optional.ofNullable(str).map(String::isBlank).orElse(true);
вы можете использовать StringUtils.isEmpty (), это приведет к true, если строка либо null, либо пуста.
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");
}
в результате
str1 равно null или пусто
str2 равно null или пусто
Я бы посоветовал Guava или Apache Commons В соответствии с вашими фактическими потребностями. Проверьте различные поведения в моем примере кода:
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");
}
}
}
результат:
Апач:
a пуст
B является пустым
C является пустым
Google:
б NullOrEmpty
C-это NullOrEmpty
если вы используете Java 8 и хотите иметь более функциональный подход программирования, вы можете определить Function
, управляющего управления, а затем вы можете использовать его и apply()
всякий раз, когда это необходимо.
приходя на практику, вы можете определить Function
as
Function<String, Boolean> isNotEmpty = s -> s != null && !"".equals(s)
тогда вы можете использовать его, просто вызвав apply()
метод as:
String emptyString = "";
isNotEmpty.apply(emptyString); // this will return false
String notEmptyString = "StackOverflow";
isNotEmpty.apply(notEmptyString); // this will return true
если вы предпочитаете, вы можете определить Function
это проверяет, если String
пусто, а затем отрицает его с !
.
в этом случае Function
будет выглядеть как :
Function<String, Boolean> isEmpty = s -> s == null || "".equals(s)
тогда вы можете использовать его, просто вызвав apply()
метод as:
String emptyString = "";
!isEmpty.apply(emptyString); // this will return false
String notEmptyString = "StackOverflow";
!isEmpty.apply(notEmptyString); // this will return true
для полноты: если вы уже используя Spring framework, the StringUtils обеспечить метод
org.springframework.util.StringUtils.hasLength(String str)
возвращает: true, если строка не имеет значения null и имеет длину
а также метод
org.springframework.util.StringUtils.hasText(String str)
возвращает: true если строка не имеет значения null, ее длина больше 0 и она не содержит пробелов только
просто, чтобы игнорировать пробелы, а также:
if (str == null || str.trim().length() == 0) {
// str is empty
} else {
// str is not empty
}
Если вы используете Spring framework, вы можете использовать метод:
org.springframework.util.StringUtils.isEmpty(@Nullable Object str);
этот метод принимает объект в качестве аргумента, сравнивая его с null и пустую строку. Как следствие, этот метод никогда не будет возвращать true для ненулевого объекта без строки.
С Java 8 Необязательно вы можете сделать:
public Boolean isStringCorrect(String str) {
return Optional.ofNullable(str)
.map(String::trim)
.map(string -> !str.isEmpty())
.orElse(false);
}
в этом выражении, вы будете обрабатывать String
, состоящие из помещений.
лучший способ обработки null в строке -
str!=null && !str.equalsIgnoreCase("null") && !str.isEmpty()
короче,
str.length()>0 && !str.equalsIgnoreCase("null")