Разница между нулевой и пустой («») строкой Java

В чем разница между 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 выдаст a, NullPointerExceptionесли вы попытаетесь вызвать, скажем:

b.length()

Если разница, которая вас интересует, равна == против равных, то это:

== сравнивает ссылки, как будто я пошел

String a = new String("");
String b = new String("");
System.out.println(a==b);

Это вывело бы false, потому что я выделил два разных объекта, а a и b указывают на разные объекты.

Однако a.equals(b)в этом случае будет возвращено значение true, поскольку equalsдля Strings будет возвращаться значение true в том и только в том случае, если аргумент String не является нулевым и представляет одинаковую последовательность символов.

Однако следует помнить, что в Java есть особый случай для строк.

String a = "abc";
String b = "abc";
System.out.println(a==b);

Вы могли бы подумать, что вывод будет false, так как он должен выделить две разные строки. Фактически, Java будет интернализировать буквальные строки (те, которые инициализируются как a и b в нашем примере). Так что будьте осторожны, потому что это может дать некоторые ложные срабатывания о том, как == работает.

Вы также можете понять разницу между нулевой и пустой строкой следующим образом:

Оригинальное изображение Р. Сато ( @raysato )

Строка является объектом и может быть нулевой

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 - пустая переменная - там буквально ничего нет.

Между ними есть довольно существенная разница. Пустая строка"" - это «строка, в которой нет символов». Это фактическая строка, которая имеет четко определенную длину. Все стандартные строковые операции четко определены в пустой строке - вы можете преобразовать ее в нижний регистр, найти индекс некоторого символа в ней и т. Д. Нулевая строка null- «вообще нет строки». У него нет длины, потому что это вовсе не строка. Попытка применить любую стандартную строковую операцию к пустой строке приведет к выполнению NullPointerExceptionво время выполнения.

сюда , a is an Objectно b(null)это не объектно это ссылка нулевой

System.out.println(a instanceof Object); // true

System.out.println(b instanceof Object); // false

вот мой аналогичный ответ

null означает, что имя не ссылается ни на один экземпляр объекта. «» означает пустую строку.

Здесь a ссылается на некоторый объект, который оказывается пустой строкой. b не ссылается ни на какой объект, так как он нулевой.

В Java назначенный ссылочный тип 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.

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

Из статьи в википедии на пустую строку .

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строку.

Когда пишешь

String a = "";

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

Тогда как когда ты пишешь

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 - пустая строковая переменная .

Разница между нулевой и пустой строкой. Например: у вас есть переменная с именем x. Если вы пишете в JS,

var x = "";

это означает, что вы присвоили значение, которое является пустой строкой (длина равна 0). На самом деле это похоже на что-то, но это ничего не чувствую :) С другой стороны,

var y = null;

это означает, что вы не присвоили y значение, которое было ясно сказано путем записи значения null y во время объявления. Если вы напишите y.length; он выдаст ошибку, которая указывает, что никакое значение не назначено y и в результате не может прочитать длину y.

Это изображение может помочь вам понять различия.

Изображение было взято из ProgrammerHumor

«Я называю это своей ошибкой в ​​миллиард долларов. Это было изобретение нулевой ссылки в 1965 году» - https://en.wikipedia.org/wiki/Tony_Hoare

Что касается реального мира, то и то и другое можно предположить одинаково. Это всего лишь синтаксис языка программирования, который создает разницу между двумя, как объяснено здесь другими. Это просто создает накладные расходы, как при проверке / сравнении, имеет ли строковая переменная что-то, вы должны сначала проверить, не является ли она нулевым, а затем фактическое сравнение строк, т.е. два сравнения. Это пустая трата вычислительной мощности для сравнения каждой строки.

Objects.equals () проверяет наличие нуля перед вызовом .equals ().

как любопытство

    String s1 = null;
    String s2 = "hello";

     s1 = s1 + s2;
   

    System.out.println((s); // nullhello