Я хочу выполнить некоторое действие ТОЛЬКО ЕСЛИ моя строка имеет значимое значение. Поэтому я попробовал следующее.
if (!myString.equals("")) {
doSomething
}
и это
if (!myString.equals(null)) {
doSomething
}
и это
if ( (!myString.equals("")) && (!myString.equals(null))) {
doSomething
}
и это
if ( (!myString.equals("")) && (myString!=null)) {
doSomething
}
и это
if ( myString.length()>0) {
doSomething
}
И во всех случаях моя программа doSomething
, несмотря на то, что моя строка ПУСТАЯ. Она равна null
. Так что же здесь не так?
ADDED:
Я нашел причину проблемы. Переменная была объявлена как строка и, как следствие, null
, присвоенный этой переменной, трансформировался в "null"
! Таким образом, if (!myString.equals("null"))
работает.
if (myString != null && !myString.isEmpty()) {
// doSomething
}
В качестве дополнительного комментария, вы должны знать об этом термине в контракте equals
:
Для любого не null значения ссылки
x
,x.equals(null)
должновозвращать false
.
Способ сравнения с null
заключается в использовании x == null
и x != null
.
Более того, x.field
и x.method()
выбрасывают NullPointerException
, если x == null
.
Если mystring совсем
нулевой
, то вызов mystring совсем.равно(нуль)
или mystring совсем.равна(" по себе")
не будет исключение NullPointerException
. Вы не можете вызывать методы экземпляра на значение null.
Проверить на null первый такой:
if (myString != null && !myString.equals("")) {
//do something
}
Это делает использование короткое замыкание оценки не попытка .равен
если mystring совсем
не нулевой чек.
StringUtils Апачи Commons лицензии.isNotEmpty` является лучшим способом, чтобы пойти.
Если mystring не в действительности нулевой, то любой вызов ссылка будет не с исключение нулевого указателя (НПЭ). Начиная с Java 6, использовать #isEmpty возвращает вместо проверки длины (ни в коем случае не создать новую пустую строку с проверкой).
if (myString !=null && !myString.isEmpty()){
doSomething();
}
Кстати, если сравнивать с строковые литералы, как и Вы, могла бы отменить заявление, чтобы не иметь проверку на null, я.е
if (("some string to check").equals(myString)){
doSomething();
}
вместо :
if (myString !=null && !myString.equals("some string to check")){
doSomething();
}
Работа !!!!
if (myString != null && !myString.isEmpty()) {
return true;
}
else {
return false;
}
Вам необходимо проверить, что объект myString
является null
:
if (myString != null) {
doSomething
}
Если ваша строка имеет значение null, как это должно бросать исключение NullReferenceException:
mystring совсем.равно(нуль)
Но в любом случае, я думаю, что подобного метода является то, что вы хотите:
public static class StringUtils
{
public static bool isNullOrEmpty(String myString)
{
return myString == null || "".equals(myString);
}
}
Тогда в вашем коде, вы можете делать вещи, как это:
if (!StringUtils.isNullOrEmpty(myString))
{
doSomething();
}
if (myString != null && myString.length() > 0) {
// your magic here
}
Кстати, если вы делаете много операций со строками, там'ы большой весенний класса со всякими полезными методами:
http://static.springsource.org/spring/docs/2.5.x/api/org/springframework/util/StringUtils.html
Каждый раз, когда я имею дело со строками (почти каждый раз) я останавливаюсь и задаться вопросом, какой способ действительно самый быстрый способ, чтобы проверить на пустую строку. Конечно, строки.Длина == 0 проверьте должно быть быстрым так как длина-это свойство, и там должны'т быть любая обработка, прочих, чем извлечение значения свойства. Но тогда я спрашиваю себя, почему есть строка.Пуст? Она должна быть быстрее, чтобы проверить строку.Пустые, чем длина, говорю я себе. Ну я наконец решил проверить его. Я кодировал консоль небольшое приложение для Windows, которое говорит мне, как долго это берет, чтобы сделать некий чек на 10 миллионов repitions. Я проверил 3 разных строки: пустая строка, пустая строка, и " Мои" в строку. Я использовал 5 различных методов: строка.IsNullOrEmpty(), ул. == нуль, ул. == нуль || ул. == строка.Пустые, ул. == нуль || ул. == " по себе", ул. == нуль || ул. длина == 0. Ниже приведены результаты:
String.IsNullOrEmpty()
NULL = 62 milliseconds
Empty = 46 milliseconds
"" = 46 milliseconds
str == null
NULL = 31 milliseconds
Empty = 46 milliseconds
"" = 31 milliseconds
str == null || str == String.Empty
NULL = 46 milliseconds
Empty = 62 milliseconds
"" = 359 milliseconds
str == null || str == ""
NULL = 46 milliseconds
Empty = 343 milliseconds
"" = 78 milliseconds
str == null || str.length == 0
NULL = 31 milliseconds
Empty = 63 milliseconds
"" = 62 milliseconds
Согласно этим результатам, в среднем проверка ул. == null является самым быстрым, но, возможно, не всегда дают то, что мы'вновь ищу.
если стр = строки.Пустыеили
стр = " и"в, это приводит к ложной. Тогда у вас есть 2, которые привязаны на втором месте:
строки.IsNullOrEmpty () " и " ул. == нуль || ул. длина == 0. С Строку.IsNullOrEmpty()
выглядит приятнее и легче (и быстрее) написать я бы рекомендовал использовать его на другие решения.
Я хотел бы предложить, используя существующие программы или создать свой собственный метод:
public static boolean isEmpty(String string) {
return string == null || string.length() == 0;
}
Затем просто использовать его, когда вам это нужно:
if (! StringUtils.isEmpty(string)) {
// do something
}
Как отмечалось выше, | | и &АМП;& операторы короткого замыкания. Это значит, что как только они смогут определить их значение, они останавливаются. Итак, если (string == null) - это правда, длина рабочей части не должны быть оценены, так как выражение всегда будет истинным. Аналогично с &&, где, если левая часть значение false, то выражение всегда ложно и не должны быть оценены дополнительно.
Как дополнительное Примечание, используя длину обычно лучше, чем при использовании .равных. Производительность чуть лучше (не намного), а не'т требует создания объекта (хотя в большинстве компиляторы могут оптимизировать это).
Я использую StringUtil.епусто(строка)`
Это тесты, Если строка является пустой: нулевой, emtpy, или только пробелы.
Так что это один из лучших до сих пор
Вот метод первоначально документы
/**
* Tests if a string is blank: null, emtpy, or only whitespace (" ", \r\n, \t, etc)
* @param string string to test
* @return if string is blank
*/
public static boolean isBlank(String string) {
if (string == null || string.length() == 0)
return true;
int l = string.length();
for (int i = 0; i < l; i++) {
if (!StringUtil.isWhitespace(string.codePointAt(i)))
return false;
}
return true;
}
Я'd сделать что-то вроде этого:
( myString != null && myString.length() > 0 )
? doSomething() : System.out.println("Non valid String");
Для меня лучше проверить, если строка содержит какие-либо значимого контента в Java-это один:
string != null && !string.trim().isEmpty()
Сначала вам проверить, если строка имеет значение null, чтобы избежать `исключение NullPointerException, а потом обрезать все пробелы, чтобы избежать проверки строки, содержащие только пробелы, и, наконец, проверьте, если обрезается строка не пуста, я.Е имеет длину 0.
Так это как типы данных, работать в Java. (Извините меня за мой английский, я возм. не используя правильный словарь. Вы должны различать два из них. Базовые типы данных и нормального типов. Базовые типы данных довольно много, составляют все, что существует. Например, есть все цифры, символ, логическое значение и т. д. Нормальные типы данных или сложные типы данных-это все остальное. Строка-это массив символов, следовательно, сложный тип данных.
Каждая переменная, которую вы создаете-это фактически указатель на значение в памяти. Например:
String s = new String("This is just a test");
переменная "и с" не содержат строку. Это указатель. Этот указатель указывает на переменную в памяти.
Когда вы звоните системе.из.код println(какой-либо объект), то
метод toString()метод этот объект называется. Если его не переопределить
метод toString` от объекта, он будет печатать указатель.
Например:
public class Foo{
public static void main(String[] args) {
Foo f = new Foo();
System.out.println(f);
}
}
>>>>
>>>>
>>>>Foo@330bedb4
Все позади и"@" это указатель. Это работает только для сложных типов данных. Примитивные типы данных, непосредственно сохранены в их указатель. Так что на самом деле нет никакого указателя и значения хранятся непосредственно.
Например:
int i = 123;
я не хранить указатель в этом случае. я буду хранить целочисленное значение 123 (в байт ОФК).
Ладно, давай вернемся к оператор==
.
Он всегда сравнивает указатель, а не содержимое на указатель's позиции в памяти.
Пример:
String s1 = new String("Hallo");
String s2 = new String("Hallo");
System.out.println(s1 == s2);
>>>>> false
Это обе строки имеют другой указатель. Строку.однако равных(строкой) сравнивает содержание. Вы можете сравнить примитивные типы данных с '==' оператор, потому что указатель на два разных объекта с одинаковым содержанием равны.
Значение null означает, что указатель пустой. Пустой примитивный тип данных по умолчанию-0 (для чисел). Однако значение null для любого сложного объекта означает, что объект не существует.
Привет
Это должно работать:
if (myString != null && !myString.equals(""))
doSomething
}
Если нет, то например, вероятно, имеет значение, что вы не ожидаете. Попробуйте напечатать его как это:
System.out.println("+" + myString + "+");
С помощью '+' символы окружают строки покажет вам, если есть лишние пробелы там, что вы'повторно не приходится.
Я имел эту проблему в Android, и я использую этот способ (работает для меня):
String test = null;
if(test == "null"){
// Do work
}
Но в Java-код я использую :
String test = null;
if(test == null){
// Do work
}
И :
private Integer compareDateStrings(BeanToDoTask arg0, BeanToDoTask arg1, String strProperty) {
String strDate0 = BeanUtils.getProperty(arg0, strProperty);_logger.debug("strDate0 = " + strDate0);
String strDate1 = BeanUtils.getProperty(arg1, strProperty);_logger.debug("strDate1 = " + strDate1);
return compareDateStrings(strDate0, strDate1);
}
private Integer compareDateStrings(String strDate0, String strDate1) {
int cmp = 0;
if (isEmpty(strDate0)) {
if (isNotEmpty(strDate1)) {
cmp = -1;
} else {
cmp = 0;
}
} else if (isEmpty(strDate1)) {
cmp = 1;
} else {
cmp = strDate0.compareTo(strDate1);
}
return cmp;
}
private boolean isEmpty(String str) {
return str == null || str.isEmpty();
}
private boolean isNotEmpty(String str) {
return !isEmpty(str);
}
Я предпочитаю использовать:
if(!StringUtils.isBlank(myString)) { // checks if myString is whitespace, empty, or null
// do something
}
В Android вы можете проверить это с пустой служебный метод от
TextUtils`,
public static boolean isEmpty(CharSequence str) {
return str == null || str.length() == 0;
}
isEmpty возвращает метод STR(объект CharSequence)
проверьте состояние, на нуль
и длина.