Как я могу проверить, является ли строка не нулевой и не пустой?
public void doStuff(String str)
{
if (str != null && str != "**here I want to check the 'str' is empty or not**")
{
/* handle empty string */
}
/* ... */
}
Как я могу проверить, является ли строка не нулевой и не пустой?
public void doStuff(String str)
{
if (str != null && str != "**here I want to check the 'str' is empty or not**")
{
/* handle empty string */
}
/* ... */
}
Ответы:
Что насчет isEmpty () ?
if(str != null && !str.isEmpty())
Обязательно используйте части &&
в этом порядке, потому что java не будет выполнять оценку второй части, если первая часть &&
потерпит неудачу, таким образом гарантируя, что вы не получите исключение нулевого указателя из str.isEmpty()
ifstr
is null.
Осторожно, он доступен только с Java SE 1.6. Вы должны проверить str.length() == 0
на предыдущих версиях.
Чтобы также игнорировать пробелы:
if(str != null && !str.trim().isEmpty())
(поскольку Java 11 str.trim().isEmpty()
может быть уменьшена доstr.isBlank()
который также будет проверять другие пробелы Юникода)
Завернут в удобную функцию:
public static boolean empty( final String s ) {
// Null-safe, short-circuit evaluation.
return s == null || s.trim().isEmpty();
}
становится:
if( !empty( str ) )
isEmpty()
требуется экземпляр String (нестатический). Вызов этого для нулевой ссылки вызовет исключение NullPointerException.
TextUtils.isEmpty(String)
для проверки, является ли строка пустой или нулевой. Хороший и короткий. Класс TextUtils является частью Android SDK.
(str != null && str.length() > 0)
.
Мне нравится использовать Apache commons-lang для таких вещей, особенно для класса утилит StringUtils :
import org.apache.commons.lang.StringUtils;
if (StringUtils.isNotBlank(str)) {
...
}
if (StringUtils.isBlank(str)) {
...
}
isEmpty
или isBlank
, может быть, не стоит включать стороннюю библиотеку. Вы можете просто создать свой собственный служебный класс для предоставления такого метода. Однако, как объясняет Божо, commons-lang
проект предоставляет много полезных методов!
StringUtils.isNotBlank(str)
делает нуль-проверку.
Просто добавьте Android здесь:
import android.text.TextUtils;
if (!TextUtils.isEmpty(str)) {
...
}
Чтобы добавить к @BJorn и @SeanPatrickFloyd Guava способ сделать это:
Strings.nullToEmpty(str).isEmpty();
// or
Strings.isNullOrEmpty(str);
Временами Commons Lang читается лучше, но я все больше полагаюсь на Гуаву, и иногда Commons Lang сбивает с толку, когда дело доходит до isBlank()
(например, что такое пробел или нет).
Версия Commons Lang для Guava isBlank
:
Strings.nullToEmpty(str).trim().isEmpty()
Я скажу, что код, который не допускает ""
(пустой) AND, null
является подозрительным и потенциально ошибочным, поскольку он, вероятно, не обрабатывает все случаи, когда запрещение null
имеет смысл (хотя для SQL я могу понять, что SQL / HQL странный вопрос ''
).
str != null && str.length() != 0
альтернативно
str != null && !str.equals("")
или
str != null && !"".equals(str)
Примечание. Вторая проверка (первая и вторая альтернативы) предполагает, что str не равен нулю. Это нормально только потому, что первая проверка делает это (а Java не выполняет вторую проверку, если первая ложна)!
ВАЖНО: НЕ используйте == для равенства строк. == проверяет, равен ли указатель, а не значение. Две строки могут быть в разных адресах памяти (два экземпляра), но иметь одинаковое значение!
Почти каждая библиотека, которую я знаю, определяет служебный класс, называемый StringUtils
, StringUtil
или StringHelper
, и они обычно включают в себя метод, который вы ищете.
Мой личный фаворит - Apache Commons / Lang , где в классе StringUtils вы получаете оба
(Первая проверяет, является ли строка пустой или пустой, вторая проверяет, является ли она пустой, пустой или только пробелом)
В Spring, Wicket и многих других библиотеках есть схожие утилиты. Если вы не используете внешние библиотеки, вы можете захотеть ввести класс StringUtils в свой собственный проект.
Прошло много лет, и в эти дни я бы рекомендовал использовать: Update Guava «s Strings.isNullOrEmpty(string)
метод.
Это работает для меня:
import com.google.common.base.Strings;
if (!Strings.isNullOrEmpty(myString)) {
return myString;
}
Возвращает true, если заданная строка равна нулю или является пустой строкой.
Попробуйте нормализовать ссылки на строки с помощью nullToEmpty. Если вы это сделаете, вы можете использовать String.isEmpty () вместо этого метода, и вам также не понадобятся специальные безопасные от нуля формы методов, такие как String.toUpperCase. Или, если вы хотите нормализовать «в другом направлении» преобразование пустых строк в ноль, вы можете использовать emptyToNull.
Как насчет:
if(str!= null && str.length() != 0 )
&&
if str == null, тем самым предотвращая исключение NullPointerException. (Источник: я только что попробовал)
Используйте метод isNotBlank от Apache StringUtils, например
StringUtils.isNotBlank(str)
Он вернет true только в том случае, если str не является нулевым и не пустым.
Вы должны использовать org.apache.commons.lang3.StringUtils.isNotBlank()
или org.apache.commons.lang3.StringUtils.isNotEmpty
. Решение между этими двумя основано на том, что вы действительно хотите проверить.
В isNotBlank () проверяет , что входной параметр является:
IsNotEmpty () проверяет только то , что входной параметр является
Возвращает истину или ложь на основе ввода
Predicate<String> p = (s)-> ( s != null && !s.isEmpty());
p.test(string);
Если вы не хотите включать всю библиотеку; просто включите код, который вы хотите от него. Вы должны будете поддержать это самостоятельно; но это довольно простая функция. Вот это скопировано с 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;
}
Слишком поздно, но вот функциональный стиль проверки:
Optional.ofNullable(str)
.filter(s -> !(s.trim().isEmpty()))
.ifPresent(result -> {
// your query setup goes here
});
Есть новый метод в Java-11: String#isBlank
Возвращает true, если строка пуста или содержит только пробельные кодовые точки, в противном случае false.
jshell> "".isBlank()
$7 ==> true
jshell> " ".isBlank()
$8 ==> true
jshell> " ! ".isBlank()
$9 ==> false
Это может быть объединено с Optional
проверкой, является ли строка нулевой или пустой
boolean isNullOrEmpty = Optional.ofNullable(str).map(String::isBlank).orElse(true);
test равен пустой строке и null в том же условном выражении:
if(!"".equals(str) && str != null) {
// do stuff.
}
Не выдает, NullPointerException
если str равен нулю, так как Object.equals()
возвращает false, если аргумент равен null
.
другая конструкция str.equals("")
бросила бы страшных NullPointerException
. Некоторые могут подумать о плохой форме, используя строковый литерал в качестве объекта, который equals()
вызывается, но он выполняет свою работу.
Также проверьте этот ответ: https://stackoverflow.com/a/531825/1532705
str != null
. !"".equals(str)
уже делаю работу
Как сказал выше 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 **/
}
Могу ли я также порекомендовать вам ссылаться на столбцы в наборе результатов по имени, а не по индексу, это облегчит поддержку вашего кода.
Я сделал свою собственную служебную функцию для проверки нескольких строк одновременно, вместо того, чтобы заполнять оператор 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
}
areSet(String... strings)
затем можно вызывать без создания массива:if(!StringUtils.areSet(firstName, lastName, address))
Если вы используете Java 8 и хотите иметь более функциональный подход к программированию, вы можете определить элемент Function
управления, который будет управлять элементом управления, а затем использовать его повторно и apply()
всякий раз, когда это необходимо.
Приступая к практике, вы можете определить Function
как
Function<String, Boolean> isNotEmpty = s -> s != null && !"".equals(s)
Затем вы можете использовать его, просто вызвав apply()
метод как:
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()
метод как:
String emptyString = "";
!isEmpty.apply(emptyString); // this will return false
String notEmptyString = "StackOverflow";
!isEmpty.apply(notEmptyString); // this will return true
С Java 8 дополнительно вы можете сделать:
public Boolean isStringCorrect(String str) {
return Optional.ofNullable(str)
.map(String::trim)
.map(string -> !str.isEmpty())
.orElse(false);
}
В этом выражении вы будете обрабатывать String
s, которые также состоят из пробелов.
Вы можете использовать StringUtils.isEmpty (), он будет иметь значение true, если строка является пустой или пустой.
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 является нулевым или пустым
str2 является нулевым или пустым
isNotBlank
Я бы посоветовал 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");
}
}
}
Результат:
Apache:
a пусто
b пусто
c пусто
Google:
b равно NullOrEmpty
c равно NullOrEmpty
Для полноты: если вы уже используете среду Spring , StringUtils предоставляет метод
org.springframework.util.StringUtils.hasLength(String str)
Возвращает: true, если строка не нулевая и имеет длину
а также метод
org.springframework.util.StringUtils.hasText(String str)
Возвращает: true, если строка не равна нулю, ее длина больше 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);
Этот метод принимает любой объект в качестве аргумента, сравнивая его с нулем и пустой строкой. Как следствие, этот метод никогда не вернет true для ненулевого не-строкового объекта.
StringUtils
явно указано «В основном для внутреннего использования в рамках; рассмотрим Apache Commons Lang для более полного набора утилит String».
Лучший способ обработать нуль в строке:
str!=null && !str.equalsIgnoreCase("null") && !str.isEmpty()
Короче говоря,
str.length()>0 && !str.equalsIgnoreCase("null")
Проверить, все ли строковые атрибуты в объекте пусты (вместо использования! = Null во всех именах полей в соответствии с подходом API Java-отражения)
private String name1;
private String name2;
private String name3;
public boolean isEmpty() {
for (Field field : this.getClass().getDeclaredFields()) {
try {
field.setAccessible(true);
if (field.get(this) != null) {
return false;
}
} catch (Exception e) {
System.out.println("Exception occurred in processing");
}
}
return true;
}
Этот метод возвратил бы true, если все значения поля String являются пустыми, Он возвратил бы false, если в атрибутах String присутствует какое-либо одно значение
Я столкнулся с ситуацией, когда я должен проверить, что «ноль» (как строка) должен рассматриваться как пустой. Также пробел и фактический нуль должны возвращать true. Я наконец остановился на следующей функции ...
public boolean isEmpty(String testString) {
return ((null==testString) || "".equals((""+testString).trim()) || "null".equals((""+testString).toLowerCase()));
}
Если вам нужно проверить параметры вашего метода, вы можете использовать следующий простой метод
public class StringUtils {
static boolean anyEmptyString(String ... strings) {
return Stream.of(strings).anyMatch(s -> s == null || s.isEmpty());
}
}
Пример:
public String concatenate(String firstName, String lastName) {
if(StringUtils.anyBlankString(firstName, lastName)) {
throw new IllegalArgumentException("Empty field found");
}
return firstName + " " + lastName;
}
PreparedStatement
и такое вместо того, чтобы создавать запрос SQL с помощью примитивов конкатенации строк. Предотвращает все виды инъекционных уязвимостей, гораздо более читабельны и т. Д.