В чем разница между null и "" (пустая строка)?
Я написал простой код:
String a = "";
String b = null;
System.out.println(a == b); // false
System.out.println(a.equals(b)); // false
Оба утверждения возвращают false. Кажется, я не могу найти, какова реальная разница между ними.
"" - фактическая строка, хотя и пустая.
null, однако, означает, что переменная String не указывает ничего.
a==b возвращает false, потому что "" и null не занимают одно и то же пространство в памяти - другими словами, их переменные не указывают на одни и те же объекты.
a.equals(b) возвращает false, потому что "" не равно нулю, очевидно.
Разница заключается в том, что, поскольку "" является фактической строкой, вы все равно можете вызывать методы или функции на ней, например
a.length()
a.substring(0, 1)
и т.д.
Если String равно null, как и b, Java выбрала бы NullPointerException, если вы попытались вызвать, скажем:
b.length()
Если разница, о которой вам интересно, равна == versus equals, это:
== сравнивает ссылки, например, если я пошел
String a = new String("");
String b = new String("");
System.out.println(a==b);
Это приведет к выводу false, потому что я выделил два разных объекта, а a и b - разные объекты.
Однако a.equals(b) в этом случае вернет true, потому что equals для строк вернет true тогда и только тогда, когда аргумент String не равен NULL и представляет ту же последовательность символы.
Будем предупреждать, что Java имеет специальный случай для строк.
String a = "abc";
String b = "abc";
System.out.println(a==b);
Вы думаете, что выход будет false, так как он должен выделять две разные строки. Фактически, Java будет intern буквальными строками (те, которые в нашем примере инициализируются как a и b). Поэтому будьте осторожны, потому что это может дать некоторые ложные срабатывания в отношении того, как работает ==.
Вы также можете понять разницу между нулевой и пустой строкой следующим образом:
Строка - это объект и может быть нулевой
null означает, что объект String не был создан
"- это фактическое значение созданной таким образом Object String как" aaa"
Вот ссылка, которая может уточнить, что точка http://download.oracle.com/javase/tutorial/java/concepts/object.html
То, что ваши заявления говорят вам, это просто то, что "не совпадает с нулем - это правда." " - пустая строка; null означает, что значение не было назначено.
Возможно, было бы более полезно просчитать:
System.out.println(a.length()); // 0
System.out.println(b.length()); // error; b is not an object
"" по-прежнему является строкой, то есть вы можете вызвать ее методы и получить значимую информацию. null - пустая переменная - там буквально ничего нет.
здесь a is an Object, но b(null) не Объект - это нулевая ссылка
System.out.println(a instanceof Object); // true
System.out.println(b instanceof Object); // false
вот мой похожий ответ
Существует довольно значительная разница между ними. Пустая строка "" - это "строка, в которой нет символов". Это фактическая строка с четко определенной длиной. Все стандартные строковые операции хорошо определены в пустой строке - вы можете преобразовать их в нижний регистр, посмотреть индекс какого-либо символа в нем и т.д. Нулевая строка null - это "никакая строка вообще". Он не имеет длины, потому что это не строка. Попытка применить любую стандартную операцию строки к пустой строке приведет к NullPointerException во время выполнения.
null означает, что имя не ссылается на какой-либо экземплярный объект. "" означает пустую строку.
Здесь a ссылается на какой-то объект, который является пустой строкой. b не ссылается ни на какой объект, как на null.
В Java ссылочный тип, назначенный null, имеет no value вообще. Строка, назначенная "", имеет значение: пустая строка, которая должна содержать строку, в которой нет символов. Когда переменной присваивается null, это означает, что нет никакого базового объекта любого типа, строки или иначе.
"" и null оба варианта. первый из них означает, что в качестве части объявления строковой переменной строковая константа была создана в пуле строк, и некоторая память была назначена для нее.
Но когда мы объявляем его с null, тогда он только что был создан jvm, но для него не было выделено никакой памяти. поэтому, если вы пытаетесь получить доступ к этому объекту, проверив его с помощью "" - пустой переменной, он не может предотвратить использование nullpointerexception. Ниже вы найдете один вариант использования.
public class StringCheck {
public static void main(String[] args) {
// TODO Auto-generated method stub
String s1 = "siddhartha";
String s2 = "";
String s3 = null;
System.out.println("length s1 ="+s1.length());
System.out.println("length s2 ="+s2.length());
//this piece of code will still throw nullpointerexception .
if(s3 != ""){
System.out.println("length s3 ="+s3.length());
}
}
}
String s = "";
s.length();
String s = null;
s.length();
Ссылка на пустую строку "" указывает на объект в куче - поэтому вы можете вызывать методы на нем.
Но ссылка, указывающая на null, не имеет объекта для точки в куче, и вы получите NullPointerException.
Пустая строка отличается от нулевой ссылкой в том, что в объектно-ориентированный язык программирования a null ссылка на тип строки не указывает на строковый объект и приведет к ошибке, чтобы попытаться выполните любую операцию на нем. Пустое строка по-прежнему является строкой, на которой могут выполняться строковые операции.
Из статьи wikipedia в пустой строке.
String s=null;
Строка не инициализируется для нуля. если какая-либо строковая операция пробовала, она может выдать исключение нулевого указателя
String t="null";
Это строковый литерал со значением string "null", таким же, как t = "xyz". Это не будет бросать нулевой указатель.
String u="";
Это как пустая строка, она не будет выбрасывать нулевой указатель.
Строка может быть пустой или иметь значение null. Если строка null, это не относится ни к чему в памяти. Попробуйте s.length()>0. Это связано с тем, что если строка пуста, она все равно возвращает длину 0. Поэтому, если вы не вводите ничего для того же самого, то она все равно продолжит цикл, так как не регистрирует строку как null. Если вы проверяете длину, то она выйдет из цикла.
Эта концепция может быть лучше понята из математики. Вы когда-нибудь пробовали делить число (не ноль) на 0 с помощью калькулятора, например, 7/0? Вы получите результат, который выглядит примерно так: undefined, not a number, null и т.д. Это означает, что операция по каким-то причинам невозможна (позвольте оставить эти причины обсуждать еще один день).
Теперь выполните следующее: 0/7. Вы получите результат 0. Это означает, что операция возможна и может быть выполнена, но вы ответ только 0, потому что после деления ничего не осталось. Существует допустимый вывод, и выход равен нулю.
В первом примере не только вывод был недействительным, но и выполнить операцию невозможно. Это похоже на строку null в java. Второй пример похож на строку empty.
Я также заметил, что хотя пустая строка является пустой строкой, она по-прежнему содержит действительный адрес памяти. Но указатель NULL будет указывать на ничто.
https://shirleyanengineer.blogspot.com/2019/01/does-empty-string-has-address.html
Когда ты пишешь
String a = "";
Это означает, что есть переменная 'a' типа string, которая указывает на ссылку на объект в пуле строк, которая имеет значение "". Поскольку переменная a содержит допустимую ссылку на строковый объект, все методы string могут быть применены здесь.
Тогда как когда ты пишешь
String b = null;
Это означает, что существует переменная b типа string, которая указывает на неизвестную ссылку. И любая операция с неизвестной ссылкой приведет к NullPointerException.
Теперь давайте оценим приведенные ниже выражения.
System.out.println(a == b); // false. because a and b both points to different object reference
System.out.println(a.equals(b)); // false, because the values at object reference pointed by a and b do not match.
System.out.println(b.equals(a)); // NullPointerException, because b is pointing to unknown reference and no operation is allowed
Проще говоря,
"" - это пустая строка
null - это пустая строковая переменная.
Это изображение может помочь вам понять различия.