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

В чем разница между null и "" (пустой строки)?

Я написал простой код:

String a = "";
String b = null;

System.out.println(a == b); // false
System.out.println(a.equals(b)); // false

Оба утверждения возвращаются false, Кажется, я не могу найти, какова реальная разница между ними.

13 ответов

Решение

"" является фактической строкой, хотя и пустой.

Однако, null означает, что переменная String ни на что не указывает.

a==b возвращает false, потому что "" и null не занимают одно и то же место в памяти - другими словами, их переменные не указывают на одни и те же объекты.

a.equals(b) возвращает false, потому что "" не равно нулю, очевидно.

Разница заключается в том, что, поскольку "" является действительной строкой, вы все равно можете вызывать методы или функции, например:

a.length()

a.substring(0, 1)

и так далее.

Если строка равна нулю, как b, Java бросит NullPointerException если вы пытались вызвать, скажите:

b.length()


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

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

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

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

Тем не мение, a.equals(b) в этом случае вернет истину, потому что equals for Strings вернет true тогда и только тогда, когда аргумент String не равен нулю и представляет ту же последовательность символов.

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

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

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

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

Разница между нулем и 0 / пустая строка

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

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 null это "нет строки вообще." У него нет длины, потому что это вовсе не строка. Попытка применить любую стандартную строковую операцию к пустой строке вызовет NullPointerException во время выполнения.

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

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

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

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

введите описание изображения здесь

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

Изображение было собрано с ProgrammerHumor

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ничего не значит; это означает, что вы никогда не устанавливали значение для своей переменной, но пустое значение означает, что вы установили значение для своегоString например, см. следующий пример:

String str1;
String str2 = "";

Вот str1 является null означает, что вы определили его, но еще не установили для него никакого значения, но вы определили str2 и установите для него пустое значение, чтобы оно имело значение, даже если это значение равно "";

но

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

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

Проще говоря,

  • "" - пустая строка

  • null - это пустая строковая переменная.

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

var x = "";

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

var y = null;

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

Замечательные ответы, но я бы хотел рассказать с другой точки зрения.

String a = "Stackru";
String a1 = "Stackru" + "";
String a2 = "Stackru" + null;

System.out.println(a == a1); // true
System.out.println(a == a2); // false

Таким образом, это может сказать нам "" и нулевую точку на различные ссылки на объекты.

Я также заметил, что хотя пустая строка является пустой строкой, она по-прежнему содержит действительный адрес памяти. Но указатель NULL будет указывать на ничто.

https://shirleyanengineer.blogspot.com/2019/01/does-empty-string-has-address.html

Эта концепция может быть лучше понята из математики. Вы когда-нибудь пробовали делить число (не ноль) на 0 с помощью калькулятора, например, 7/0? Вы получите результат, который выглядит примерно так: undefined, not a number, null и т.д. Это означает, что операция невозможна по некоторым причинам (давайте оставим эти причины для обсуждения в другой день).

Теперь выполните это: 0/7. Вы получите вывод 0. Это означает, что операция возможна и может быть выполнена, но вы ответите просто 0, потому что после деления ничего не осталось. Имеется действительный вывод, и этот вывод равен нулю.

В первом примере выходные данные были не только недействительными, но и не позволяли выполнить операцию. Это сродни null Строка в Java. Второй пример сродни empty строка.

Строка может быть пустой или иметь null значение. Если строка null, это не относится к чему-либо в памяти. Пытаться s.length()>0, Это потому, что если строка пуста, она все равно возвращает длину 0. Поэтому, если вы ничего не введете для того же самого, то она все равно продолжит цикл, так как не регистрирует строку как null, Принимая во внимание, что если вы проверите длину, она выйдет из цикла.

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

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

     s1 = s1 + s2;
   

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

Когда ты пишешь

String a = "";

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

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

String b = null;

Это означает, что есть переменная b типа строка, которая указывает на неизвестную ссылку. И любая операция с неизвестной ссылкой приведет к 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

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

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

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

Другие вопросы по тегам