В java g.drawString не печатает в апплете при использовании Container [duplicate]

@if (Model != null)
{
         for (var i = 0; i < Model.Tags.Count; i++) 
         {
             <script type="text/javascript">
                  alert('@Model.Tags[i]');
             </script>
         }
}
727
задан Nathan H 23 January 2013 в 15:36
поделиться

25 ответов

== тесты для ссылочного равенства (независимо от того, являются ли они одним и тем же объектом).

.equals() тесты для равенства значений (независимо от того, являются ли они логически «равными»).

Objects.equals () проверяет наличие null перед вызовом .equals(), поэтому вам не нужно (доступно с JDK7, также доступным в Guava ).

String.contentEquals () сравнивает содержимое String с содержимым любого CharSequence (доступно с Java 1.5).

Следовательно, если вы хотите проверить, имеет ли две строки одно и то же значение, вы, вероятно, захотите использовать Objects.equals().

// These two have the same value
new String("test").equals("test") // --> true 

// ... but they are not the same object
new String("test") == "test" // --> false 

// ... neither are these
new String("test") == new String("test") // --> false 

// ... but these are because literals are interned by 
// the compiler and thus refer to the same object
"test" == "test" // --> true 

// ... string literals are concatenated by the compiler
// and the results are interned.
"test" == "te" + "st" // --> true

// ... but you should really just call Objects.equals()
Objects.equals("test", new String("test")) // --> true
Objects.equals(null, "test") // --> false
Objects.equals(null, null) // --> true

Вы почти всегда хотите использовать Objects.equals(). В редкой ситуации, когда вы знаете, что имеете дело с интернированными строками, вы можете использовать ==.

Из JLS 3.10. 5. Строковые литералы :

Кроме того, строковый литерал всегда ссылается на тот же экземпляр класса String. Это связано с тем, что строковые литералы, или, в более общем смысле, строки, которые являются значениями константных выражений ( §15.28 ), «интернированы», чтобы обмениваться уникальными экземплярами, используя метод String.intern.

. Подобные примеры также можно найти в JLS 3.10.5-1 .

4972
ответ дан 39 revs, 23 users 42% 18 August 2018 в 19:44
поделиться
  • 1
    Думаю, в Java вы должны сказать «ссылки». вместо «указателей». – Henrik Paul 5 February 2009 в 12:03
  • 2
    @ Xokas11: compareTo обычно используется для сортировки. – Michael Myers♦ 27 February 2009 в 16:17
  • 3
    Только примечание equals() точно Сравнивает эту строку с другой строкой, НО equalsIgnoreCase() сравнивает эту строку с другой строкой, игнорируя соображения случая – Yajli Maclo 28 February 2013 в 17:30
  • 4
    @SnakeDoc - Мы можем сказать обратное. Всегда используйте equals(), если у вас нет веской причины. То, что вы называете безопасностью, полностью зависит от контекста. Например, при сравнении паролей, чтобы определить, введен ли пользователь правильный пароль, небезопасно игнорировать различия в регистре. – Nicolas Barbulesco 22 August 2013 в 10:06
  • 5
    Одно незначительное редактирование, == не «намного дешевле», чем .equals, потому что первый оператор в String.equals читает: if (this == anObject) {return true; }. – Torque 10 April 2014 в 11:42

Я думаю, что когда вы определяете String, вы определяете объект. Поэтому вам нужно использовать .equals(). Когда вы используете примитивные типы данных, вы используете ==, но с String (и любым объектом) вы должны использовать .equals().

203
ответ дан 2 revs, 2 users 67% 18 August 2018 в 19:44
поделиться
  • 1
    Также обратите внимание, что == не работает для char [] – Khaled.K 24 March 2013 в 16:03
  • 2
    Обычно я настоятельно рекомендую библиотеку apache commons: commons.apache.org/proper/commons-lang/javadocs/api-2.6/org/… , java.lang.String) – Marcin Erbel 16 October 2014 в 11:32
  • 3
    & Quot; обугливается [] & Quot; не является примитивным типом данных! Это массив «char». И массивы не являются примитивными типами данных. – Christian 18 March 2015 в 22:02
  • 4
    Вы также можете использовать метод .compareTo (), если хотите оценить порядок строк. – MarekM 27 June 2017 в 14:48

Строки в Java неизменяемы. Это означает, что всякий раз, когда вы пытаетесь изменить / изменить строку, вы получаете новый экземпляр. Вы не можете изменить исходную строку. Это сделано для того, чтобы эти экземпляры строк могли кэшироваться. Типичная программа содержит множество ссылок на строки и кеширование этих экземпляров, что может уменьшить объем памяти и увеличить производительность программы.

При использовании оператора == для сравнения строк вы не сравниваете содержимое строки , но фактически сравнивают адрес памяти. Если они равны, в противном случае они вернут true и false. Если значение равно в строке, сравнивает содержимое строки.

Итак, вопрос в том, что все строки кэшируются в системе, как получается == возвращает false, тогда как equals возвращает true? Ну, это возможно. Если вы создадите новую строку, например String str = new String("Testing"), вы создадите новую строку в кеше, даже если в кеше уже содержится строка с тем же содержимым. Короче говоря, "MyString" == new String("MyString") всегда будет возвращать false.

Java также говорит о функции intern (), которая может использоваться в строке, чтобы сделать ее частью кеша, поэтому "MyString" == new String("MyString").intern() вернет true.

Примечание: == оператор намного быстрее, чем равен только потому, что вы сравниваете два адреса памяти, но вы должны быть уверены, что код не создает новые экземпляры String в коде. В противном случае вы столкнетесь с ошибками.

154
ответ дан 2 revs, 2 users 76% 18 August 2018 в 19:44
поделиться

Я согласен с ответом от zacherates.

Но вы можете сделать вызов intern () в ваших нелиберальных строках.

Из примера zacherates:

// ... but they are not the same object
new String("test") == "test" ==> false 

Если вы ставите нелитеральное равенство строки, это правда

new String("test").intern() == "test" ==> true 
114
ответ дан 2 revs, 2 users 89% 18 August 2018 в 19:44
поделиться
  • 1
    Это, как правило, не очень хорошая идея. Интернинг относительно дорог и может (парадоксально) & gt; & gt; увеличить & lt; ваш объем памяти JVMs и увеличение расходов на GC. В большинстве случаев они превосходят преимущества производительности при использовании == для сравнения строк. – Stephen C 25 September 2015 в 23:16

Если вы похожи на меня, когда я впервые начал использовать Java, я хотел использовать оператор «==» для проверки того, были ли два экземпляра String одинаковыми, но к лучшему или худшему это не правильный способ сделать это в Java.

В этом уроке я продемонстрирую несколько разных способов правильно сравнить строки Java, начиная с подхода, который я использую большую часть времени. В конце этого руководства по сопоставлению Java String я также обсужу, почему оператор «==» не работает при сравнении строк Java.

Вариант 1: Сравнение строк Java с методом equals Большая часть (возможно, в 95% случаев). Я сравниваю строки с методом equals класса Java String следующим образом:

if (string1.equals(string2))

Этот метод String равен методу для двух строк Java, и если они содержат точно такую ​​же строку символов, они считаются равными.

Взглянув на быстрый пример сравнения строк с методом equals, если был выполнен следующий тест, две строки не будут считаться равными, поскольку символы не являются точно такими же (случай символов различен):

String string1 = "foo";
String string2 = "FOO";

if (string1.equals(string2))
{
    // this line will not print because the
    // java string equals method returns false:
    System.out.println("The two strings are the same.")
}

Но, когда две строки содержат одну и ту же строку символов, метод equals вернет true, как в этот пример:

String string1 = "foo";
String string2 = "foo";

// test for equality with the java string equals method
if (string1.equals(string2))
{
    // this line WILL print
    System.out.println("The two strings are the same.")
}

Вариант 2: Сравнение строк с методом equalsIgnoreCase

В некоторых строковых сравнительных тестах вы захотите игнорируйте, являются ли строки строчными или строчными. Если вы хотите проверить свои строки на равенство в этом случае нечувствительным образом, используйте метод equalsIgnoreCase класса String, например:

String string1 = "foo";
String string2 = "FOO";

 // java string compare while ignoring case
 if (string1.equalsIgnoreCase(string2))
 {
     // this line WILL print
     System.out.println("Ignoring case, the two strings are the same.")
 }

Вариант 3: сравнение строк Java с методом compareTo

Существует также третий, менее распространенный способ сравнения строк Java, и это с методом сравнения String класса. Если две строки точно совпадают, метод compareTo вернет значение 0 (ноль). Ниже приведен краткий пример того, как выглядит этот метод сравнения строк:

String string1 = "foo bar";
String string2 = "foo bar";

// java string compare example
if (string1.compareTo(string2) == 0)
{
    // this line WILL print
    System.out.println("The two strings are the same.")
}

Пока я пишу об этой концепции равенства в Java, важно отметить, что язык Java включает в себя метод equals в базовый класс Java Object. Всякий раз, когда вы создаете свои собственные объекты, и вы хотите предоставить средства для проверки того, являются ли два экземпляра вашего объекта «равными», вы должны переопределить (и реализовать) этот метод equals в своем классе (точно так же, как язык Java предоставляет это равенство / сравнение в методе String равно).

Вы можете посмотреть на это ==, .equals (), compareTo () и compare ()

77
ответ дан 2 revs, 2 users 92% 18 August 2018 в 19:44
поделиться
  • 1
    для строковых литералов Like String string1 = & quot; foo bar & quot ;; Строка string2 = "foo bar"; вы можете напрямую использовать == оператор для проверки равенства контента – JAVA 7 September 2013 в 19:11
  • 2
    В скрипте Google Apps & quot; compareTo & quot; невозможно. Я попробовал вместо этого «равно» & quot; Это было единственное решение, которое работает ... – user3887038 24 April 2018 в 12:40

Оператор == всегда предназначен для сравнения ссылок на объекты, тогда как метод сравнения строк .equals () переопределяется для сравнения содержимого:

String s1 = new String("abc");
String s2 = new String("abc");
System.out.println(s1 == s2); // It prints false (reference comparison)
System.out.println(s1.equals(s2)); // It prints true (content comparison)
38
ответ дан 3 revs, 2 users 54% 18 August 2018 в 19:44
поделиться

В Java, когда оператор «==» используется для сравнения двух объектов, он проверяет, ссылаются ли объекты на одно и то же место в памяти. Другими словами, он проверяет, являются ли имена двух объектов в основном ссылками на одно и то же место в памяти.

Класс Java String фактически переопределяет реализацию equals () по умолчанию в классе Object и переопределяет этот метод, чтобы он проверял только значения строк, а не их местоположения в памяти. Это означает, что если вы вызываете метод equals () для сравнения двух объектов String, то, пока действительная последовательность символов равна, оба объекта считаются равными.

Оператор == проверяет, являются ли две строки точно одним и тем же объектом.

Метод .equals() проверяет, имеют ли две строки одно и то же значение.

33
ответ дан 3 revs, 2 users 88% 18 August 2018 в 19:44
поделиться
  • 1
    если только один из них не равен нулю, так как s.equals (s2) сработает, если s равно null, что приведет к сбою сравнения. Конечно, это не противоречит ответу; это просто предостережение. – Jon Coombs 20 June 2014 в 02:05
  • 2
    Нет, это не приведет к сбою, это вызовет исключение NullPointerException, в результате чего сравнение не произойдет. – Bludzee 4 March 2016 в 10:51

Вы также можете использовать метод compareTo() для сравнения двух строк. Если результат compareTo равен 0, то две строки равны, в противном случае сравниваемые строки не равны.

== сравнивает ссылки и не сравнивает фактические строки. Если вы создали каждую строку, используя new String(somestring).intern(), вы можете использовать оператор == для сравнения двух строк, в противном случае могут использоваться только методы equals () или compareTo.

35
ответ дан 3 revs, 3 users 43% 18 August 2018 в 19:44
поделиться

Все объекты гарантированно имеют метод .equals(), поскольку Object содержит метод, .equals(), который возвращает логическое значение. Задача подкласса переопределять этот метод, если требуется дополнительное определение определения. Без него (т. Е. С помощью ==) только адреса памяти проверяются между двумя объектами для равенства. String переопределяет этот метод .equals() и вместо использования адреса памяти возвращает сравнение строк на уровне символа для равенства.

Ключевое замечание состоит в том, что строки хранятся в одном пуле, поэтому после создания строки он всегда хранится в программе по тому же адресу. Строки не меняются, они неизменяемы. Вот почему это плохая идея использовать регулярную конкатенацию строк, если у вас есть серьезное количество обработки строк. Вместо этого вы будете использовать предоставленные классы StringBuilder. Помните, что указатели на эту строку могут измениться, и если вам было интересно увидеть, были ли два указателя одинаковыми ==, это был бы прекрасный способ. Строки сами не делают.

49
ответ дан 3 revs, 3 users 50% 18 August 2018 в 19:44
поделиться
  • 1
    не для nit picky, но метод equals() для String фактически находится в классе String, а не в Object. По умолчанию equals() в Object не сравнится, что содержимое одного и того же, и на самом деле просто возвращает true, когда ссылка одинаков. – Jacob Schoen 20 November 2012 в 19:04
  • 2
    "после создания строки он всегда хранится в программе с тем же адресом" - это неверно. Только константные строковые выражения времени компиляции (возможно, с участием переменных final String) и строки, в которых ваша программа явно стажеров, хранятся в том, что вы называете «куском пула». Все остальные String объекты подлежат сборке мусора, если на них больше нет ссылок на живые ссылки, как и любой другой тип объекта. Кроме того, хотя для всего интернирующего механизма требуется неизменность, в противном случае это не имеет отношения к этому. – Ted Hopp 10 April 2014 в 19:13
  • 3
    Сравнение строк выполняется либо с помощью метода equals или equalsIgnoreCase, который фактически сравнивает содержимое строки. Но знак == просто проверяет контрольные значения. Для строковых литералов из пула строк будет отлично работать для этого случая. Строка s1 = новая строка («a»); Строка s2 = новая строка («a»); в этом случае s1 == s2 является ложным, но s1.equals (s2) истинно. – Shailendra Singh 8 July 2016 в 15:31

.equals() сравнивает данные в классе (при условии, что функция реализована). == сравнивает местоположения указателя (расположение объекта в памяти).

== возвращает true, если оба объекта (NOT TALKING OF PRIMITIVES) указывают на экземпляр SAME. .equals() возвращает true, если два объекта содержат одни и те же данные equals() Versus == в Java

Это может вам помочь.

92
ответ дан 3 revs, 3 users 64% 18 August 2018 в 19:44
поделиться

Если метод equals() присутствует в классе java.lang.Object, и ожидается, что он проверяет эквивалентность состояния объектов! Это означает, что содержимое объектов. В то время как ожидается, что оператор == проверяет, что фактические экземпляры объекта одинаковы или нет.

Пример

Рассмотрим две различные ссылочные переменные, str1 и str2:

str1 = new String("abc");
str2 = new String("abc");

Если вы используете equals()

System.out.println((str1.equals(str2))?"TRUE":"FALSE");

, вы получите выход как TRUE, если вы используете ==.

System.out.println((str1==str2) ? "TRUE" : "FALSE");

Теперь вы получите вывод FALSE в качестве вывода, потому что оба str1 и str2 указывают на два разных объекта, хотя оба они имеют одинаковое строковое содержимое. Именно из-за new String() каждый новый объект создается каждый раз.

41
ответ дан 3 revs, 3 users 79% 18 August 2018 в 19:44
поделиться

Оператор == проверяет, указывают ли две ссылки на один и тот же объект или нет. .equals() проверьте фактическое содержимое строки (значение).

Обратите внимание, что метод .equals() принадлежит классу Object (суперкласс всех классов). Вам необходимо переопределить его в соответствии с вашим требованием к классу, но для String оно уже реализовано и проверяет, имеет ли две строки одно и то же значение.

  • Случай 1
    String s1 = "Stack Overflow";
    String s2 = "Stack Overflow";
    s1 == s2;      //true
    s1.equals(s2); //true
    
    Причина: строка литералы, созданные без нуля, хранятся в пуле строк в области перментонов кучи. Таким образом, оба s1 и s2 указывают на один и тот же объект в пуле.
  • Случай 2
    String s1 = new String("Stack Overflow");
    String s2 = new String("Stack Overflow");
    s1 == s2;      //false
    s1.equals(s2); //true
    
    Причина. Если вы создаете объект String с использованием ключевого слова new, ему выделяется отдельное пространство в куче.
65
ответ дан 4 revs, 3 users 50% 18 August 2018 в 19:44
поделиться

Функция:

public float simpleSimilarity(String u, String v) {
    String[] a = u.split(" ");
    String[] b = v.split(" ");

    long correct = 0;
    int minLen = Math.min(a.length, b.length);

    for (int i = 0; i < minLen; i++) {
        String aa = a[i];
        String bb = b[i];
        int minWordLength = Math.min(aa.length(), bb.length());

        for (int j = 0; j < minWordLength; j++) {
            if (aa.charAt(j) == bb.charAt(j)) {
                correct++;
            }
        }
    }

    return (float) (((double) correct) / Math.max(u.length(), v.length()));
}

Тест:

String a = "This is the first string.";

String b = "this is not 1st string!";

// for exact string comparison, use .equals

boolean exact = a.equals(b);

// For similarity check, there are libraries for this
// Here I'll try a simple example I wrote

float similarity = simple_similarity(a,b);
73
ответ дан 4 revs, 3 users 69% 18 August 2018 в 19:44
поделиться
  • 1
    Как это отличается от других ответов? и почему так вы предлагаете – Mark 10 September 2015 в 12:27
  • 2
    @Mark На вопрос о различии между == и equals уже были ответы на другие решения, я просто предложил другой способ сравнить строки по-разному – Khaled.K 10 September 2015 в 20:45

Java имеет пул строк, в котором Java управляет распределением памяти для объектов String. См. String Pools в Java

Когда вы проверяете (сравниваете) два объекта с помощью оператора ==, он сравнивает равенство адресов в пуле строк. Если два объекта String имеют одинаковые адреса, то он возвращает true, в противном случае false. Но если вы хотите сравнить содержимое двух объектов String, вы должны переопределить метод equals.

equals - фактически метод класса Object, но он переопределяется в класс String и дается новое определение, которое сравнивает содержимое объекта.

Example:
    stringObjectOne.equals(stringObjectTwo);

Но помните, что это относится к случаю String. Если вы хотите сравнить регистр без учета регистра, вы должны пойти для метода equalsIgnoreCase класса String.

Давайте посмотрим:

String one   = "HELLO"; 
String two   = "HELLO"; 
String three = new String("HELLO"); 
String four  = "hello"; 

one == two;   // TRUE
one == three; // FALSE
one == four;  // FALSE

one.equals(two);            // TRUE
one.equals(three);          // TRUE
one.equals(four);           // FALSE
one.equalsIgnoreCase(four); // TRUE
104
ответ дан 4 revs, 3 users 80% 18 August 2018 в 19:44
поделиться
  • 1
    Я вижу, что это поздний ответ на большой вопрос. Могу ли я спросить, что он дает, что уже не упоминается в существующих ответах? – Mysticial 2 April 2013 в 10:19
  • 2
    @Mysticial он добавил equalsIgnoreCase, который может быть информативным для более свежего. – AmitG 4 April 2013 в 09:48

== выполняет контрольную проверку равенства, ссылаясь на то, что 2 объекта (строки в этом случае) относятся к одному и тому же объекту в памяти.

Метод equals() будет проверять, будет ли содержимое или состояния двух объектов одинаковы.

Очевидно, что == работает быстрее, но во многих случаях может (может) давать ложные результаты, если вы просто хотите сказать, имеет ли 2 String s тот же текст.

Определенно рекомендуется использовать метод equals().

Не беспокойтесь о производительности. Некоторые способы поощрения использования String.equals():

  1. Реализация String.equals() сначала проверяет ссылочное равенство (используя ==), и если две строки одинаковы по ссылке, дальнейший расчет Выполняется!
  2. Если 2 ссылки на строки не совпадают, String.equals() будет проверять длину строк. Это также является быстрой операцией, поскольку класс String хранит длину строки, не нужно считать символы или кодовые точки. Если длины отличаются, дальнейшая проверка не выполняется, мы знаем, что они не могут быть равными.
  3. Только если мы доберемся до этого, будет фактически сопоставлено содержимое двух строк, и это будет короткий сравнение: не все символы будут сравниваться, если мы найдем несоответствующий символ (в том же положении в 2 строках), никакие другие символы не будут проверены.

Когда все сказано и даже если у нас есть гарантия, что строки являются стажерами, использование метода equals() все еще не является издержками, которые можно было бы подумать, определенно рекомендуемым способом. Если вам нужна эффективная проверка ссылок, используйте перечисления, где гарантируется спецификацией и реализацией языка, что одно и то же значение перечисления будет одним и тем же объектом (по ссылке).

87
ответ дан 5 revs 18 August 2018 в 19:44
поделиться
  • 1
    Obviously == is faster - фактически реализация .equals(String) сначала проверяет == перед чем-либо еще, поэтому я бы сказал, что скорость примерно одинаковая. – Razzle Shazl 22 June 2018 в 06:38
  • 2
    public boolean equals(Object anObject) { if (this == anObject) { return true; } ... – Razzle Shazl 22 June 2018 в 06:51

== сравнивает ссылки на объекты.

.equals() сравнивает значения String.

Иногда == дает иллюзии сравнения значений String, как в следующих случаях:

String a="Test";
String b="Test";
if(a==b) ===> true

Это связано с тем, что при создании любого строкового литерала JVM сначала ищет этот литерал в пуле строк, и если он найдет совпадение, эта же ссылка будет передана новой String. Из-за этого получаем:

(a == b) ===> true

                       String Pool
     b -----------------> "test" <-----------------a

Однако == не выполняется в следующем случае:

String a="test";
String b=new String("test");
if (a==b) ===> false

В этом случае для new String("test") оператор new String будет создан в куче, и эта ссылка будет указана на b, поэтому b будет дана ссылка на кучу, а не на String pool.

Теперь a указывает на String в пуле String, а b указывает на String в куче. Из-за этого мы получаем:

, если (a == b) ===> false.

                String Pool
     "test" <-------------------- a

                   Heap
     "test" <-------------------- b

Пока .equals() всегда сравнивает значение String, поэтому дает true в обоих случаях:

String a="Test";
String b="Test";
if(a.equals(b)) ===> true

String a="test";
String b=new String("test");
if(a.equals(b)) ===> true

Таким образом, использование .equals() всегда лучше.

398
ответ дан 6 revs, 4 users 69% 18 August 2018 в 19:44
поделиться
  • 1
    .equals () сравнивает два экземпляра, однако equals реализован для их сравнения. Это может или не может сравнивать вывод toString. – Jacob 18 March 2016 в 03:14
  • 2
    Метод @Jacob Object class .equals() сравнивает экземпляры (ссылки / адрес), где в качестве методов класса String .equals() переопределяется для сравнения содержимого (символов) – Satyadev 7 May 2016 в 10:54
  • 3
    Хорошо указывает на различия в String pool и Java, поскольку они, конечно, не одинаковы. В пуле строк Java пытается «кэшировать»; String объекты для сохранения объема памяти, поскольку String известен тем, что он неизменен (я надеюсь, что правильно говорю здесь). Также проверьте stackoverflow.com/questions/3052442/… – Roland 10 November 2017 в 14:34

== проверяет ссылки на объекты, .equals() проверяет строковые значения.

Иногда кажется, что == сравнивает значения, потому что Java делает некоторые закулисные вещи, чтобы убедиться, что одинаковые строки в строке являются одним и тем же объектом.

Для Например:

String fooString1 = new String("foo");
String fooString2 = new String("foo");

// Evaluates to false
fooString1 == fooString2;

// Evaluates to true
fooString1.equals(fooString2);

// Evaluates to true, because Java uses the same object
"bar" == "bar";

Но будьте осторожны с нулями!

== обрабатывает строки null в порядке, но вызов .equals() из пустой строки приведет к исключению:

String nullString1 = null;
String nullString2 = null;

// Evaluates to true
System.out.print(nullString1 == nullString2);

// Throws a NullPointerException
System.out.print(nullString1.equals(nullString2));

Итак, если вы знаете, что fooString1 может но не менее очевидно, что он проверяет значение null (из Java 7):

System.out.print(Objects.equals(fooString1, "bar"));
628
ответ дан 6 revs, 6 users 76% 18 August 2018 в 19:44
поделиться
  • 1
    Иногда это выглядит так, как будто & quot; == & quot; сравнивает значения, - == do всегда сравнивает значения! (Просто определенные значения являются ссылками!) – aioobe 24 July 2012 в 13:44
  • 2
    Увы, не существует статического метода для isNullOrEmpty (), и нет настраиваемой перегрузки операторов, что делает эту часть Java более clunkier чем в C # или Python. И поскольку Java не имеет методов расширения, вы не можете написать свою собственную утилиту для расширения java.lang.String. Правильно? Любые мысли о подклассификации String, добавление этого статического метода утилиты, а затем всегда использование MyString? Статический метод с двумя параметрами для нуль-безопасных сравнений был бы неплохо иметь и в этом подклассе. – Jon Coombs 20 June 2014 в 02:00
  • 3
    Groovy упрощает работу с безопасным навигационным оператором ( groovy.codehaus.org/… ), ?.. Это преобразует nullString1?.equals(nullString2); в полностью нулевой оператор. Однако это не поможет, если у вас есть validString?.equals(nullString); - это все еще вызывает исключение. – Charles Wood 25 June 2014 в 17:28
  • 4
    Короткие методы для сравнения нулевых строк в java: stackoverflow.com/questions/11271554/… – Vadzim 12 March 2015 в 18:19
  • 5
    @JonCoombs Java поддерживает подклассирование и создание собственного метода. Однако несколько классов отмечены окончательными по определенным причинам, String является одним из них, поэтому мы не можем распространяться. Мы можем создать другой класс и сделать там класс утилиты, который принимает две строки в качестве аргументов и реализует там свою логику. Также для нулевой проверки некоторых других библиотек, таких как spring и apache, у него хорошие коллекции методов, можно использовать это. – Panther 12 April 2015 в 05:05

== сравнивает ссылки на объекты в Java и не является исключением для объектов String.

Для сравнения фактического содержимого объектов (в том числе String) необходимо использовать equals.

Если сравнение двух объектов String с использованием == оказывается true, это связано с тем, что объекты String были интернированы, а виртуальная машина Java имеет несколько ссылки указывают на тот же экземпляр String. Не следует ожидать сравнения одного объекта String, содержащего то же содержимое, что и другой объект String, используя == для оценки как true.

91
ответ дан coobird 18 August 2018 в 19:44
поделиться
String a = new String("foo");
String b = new String("foo");
System.out.println(a == b); // prints false
System.out.println(a.equals(b)); // prints true

Убедитесь, что вы понимаете, почему. Это потому, что сравнение == сравнивает только ссылки; equals() метод сопоставляет содержимое по символу.

Когда вы вызываете new для a и b, каждый получает новую ссылку, указывающую на "foo" в таблице строк. Ссылки разные, но контент один и тот же.

132
ответ дан duffymo 18 August 2018 в 19:44
поделиться
203
ответ дан 2 revs, 2 users 67% 7 September 2018 в 03:57
поделиться
114
ответ дан 2 revs, 2 users 89% 7 September 2018 в 03:57
поделиться
49
ответ дан 3 revs, 3 users 50% 7 September 2018 в 03:57
поделиться
49
ответ дан 3 revs, 3 users 50% 30 October 2018 в 08:05
поделиться
206
ответ дан 2 revs, 2 users 67% 30 October 2018 в 08:05
поделиться
117
ответ дан 2 revs, 2 users 89% 30 October 2018 в 08:05
поделиться
Другие вопросы по тегам:

Похожие вопросы: