String.equals против ==

Ответ 1

Используйте функцию string.equals(Object other) для сравнения строк, а не оператора ==.

Функция проверяет фактическое содержимое строки, оператор == проверяет, равны ли ссылки на объекты. Обратите внимание, что строковые константы обычно "интернированы", так что две константы с одинаковым значением могут фактически сравниваться с ==, но лучше не полагаться на это.

if (usuario.equals(datos[0])) {
    ...
}

NB: сравнение выполняется в "usuario", потому что это гарантировало ненулевое значение в вашем коде, хотя вы все равно должны проверить, что у вас действительно есть токены в массиве datos, иначе вы получите массив, исключение из-за границы.

Ответ 2

Знакомьтесь с Йорманом

Йорман - успешный бизнесмен и имеет 2 дома.

Но другие этого не знают.

Это тот же самый Йорман?

Когда вы спрашиваете соседей по улицам Мэдисона или Берка, это единственное, что они могут сказать:

Используя одно место жительства, трудно подтвердить, что он тот же самый Йорман. Поскольку у них 2 разных адреса, вполне естественно предположить, что это два разных человека.

То, как ведет себя оператор ==. Таким образом, он скажет, что datos[0]==usuario является ложным, поскольку он сравнивает только адреса.

Следователь по спасению

Что, если мы отправим следователя? Мы знаем, что это тот же самый джорман, но нам нужно это доказать. Наш детектив внимательно рассмотрит все физические аспекты. При тщательном расследовании агент сможет заключить, является ли это одним и тем же лицом или нет. Посмотрите, как это происходит на Java.

Здесь исходный код метода String equals():

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

То, как ведет себя метод String equals. Итак, datos[0].equals(usuario) вернет true, потому что он выполняет логическое сравнение.

Ответ 3

Хорошо заметить, что в некоторых случаях использование оператора "==" может привести к ожидаемому результату, потому что интерполяция между строками java обрабатывает строки (см. String.intern()) во время компиляции - поэтому, когда вы пишете, например, "hello world" в двух классах и сравниваете эти строки с "==", вы можете получить результат: true, который ожидается в соответствии с спецификация; когда вы сравниваете одинаковые строки (если они имеют одинаковое значение), когда первый - строковый литерал (т.е. определенный через "i am string literal"), а второй - во время выполнения, т.е. с "новым" ключевым словом, таким как new String("i am string literal"), оператор == (равенство) возвращает false, потому что оба они являются разными экземплярами класса String.

Только правильный способ использует .equals() → datos[0].equals(usuario). == говорит только, если два объекта являются одним и тем же экземпляром объекта (т.е. имеют тот же адрес памяти)

Обновление: 01.04.2013 Я обновил этот комментарий после комментариев, который как-то прав. Первоначально я объявил, что интернирование (String.intern) является побочным эффектом оптимизации JVM. Хотя это, безусловно, экономит ресурсы памяти (что я имел в виду под "оптимизацией" ), это в основном особенность языка

Ответ 4

equals() Функция - это метод класса Object, который должен быть переопределен программистом. Класс String переопределяет его, чтобы проверить, равны ли две строки, т.е. в содержании, а не в ссылке.

== проверяет, совпадают ли ссылки обоих объектов.

Рассмотрим программы

String abc = "Awesome" ;
String xyz =  abc;

if(abc == xyz)
     System.out.println("Refers to same string");

Здесь abc и xyz, оба относятся к тому же String "Awesome". Следовательно, выражение (abc == xyz) равно true.

String abc = "Hello World";
String xyz = "Hello World";

if(abc == xyz)
    System.out.println("Refers to same string");
else
    System.out.println("Refers to different strings");

if(abc.equals(xyz))
     System.out.prinln("Contents of both strings are same");
else
     System.out.prinln("Contents of strings are different");

Здесь abc и xyz - две разные строки с одним и тем же содержимым "Hello World". Отсюда здесь выражение (abc == xyz) равно false, где as (abc.equals(xyz)) - true.

Надеюсь, вы поняли разницу между == и <Object>.equals()

Спасибо.

Ответ 5

Вместо

datos[0] == usuario

использовать

datos[0].equals(usuario)

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

Ответ 6

== тесты для ссылочного равенства.

.equals() тесты для равенства значений.

Следовательно, если вы действительно хотите проверить, имеет ли две строки одно и то же значение, вы должны использовать .equals() (за исключением нескольких ситуаций, когда вы можете гарантировать, что две строки с одинаковым значением будут представлены одним и тем же объектом, например: String интернирование).

== предназначен для проверки того, являются ли две строки одинаковыми Object.

// 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 

// concatenation of string literals happens at compile time resulting in same objects
"test" == "te" + "st"  ==> true

// but .substring() is invoked at runtime, generating distinct objects
"test" == "!test".substring(1) ==> false

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

Ответ 7

The == operator checks if the two references point to the same object or not.
.equals() checks for the actual string content (value).

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

Case1)
String s1 = "Stack Overflow";
String s2 = "Stack Overflow";
s1 == s1;      // true
s1.equals(s2); // true
Reason: String literals created without null are stored in the string pool in the permgen area of the heap. So both s1 and s2 point to the same object in the pool.
Case2)
String s1 = new String("Stack Overflow");
String s2 = new String("Stack Overflow");
s1 == s2;      // false
s1.equals(s2); // true
Reason: If you create a String object using the 'new' keyword a separate space is allocated to it on the heap.

Ответ 8

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

public static void main (String... aArguments) throws IOException {

String usuario = "Jorman";
String password = "14988611";

String strDatos="Jorman 14988611";
StringTokenizer tokens=new StringTokenizer(strDatos, " ");
int nDatos=tokens.countTokens();
String[] datos=new String[nDatos];
int i=0;

while(tokens.hasMoreTokens()) {
    String str=tokens.nextToken();
    datos[i]= str.intern();            
    i++;
}

//System.out.println (usuario);

if(datos[0]==usuario) {  
     System.out.println ("WORKING");    
}

Ответ 9

Проанализируйте следующую Java, чтобы понять идентичность и равенство строк:

public static void testEquality(){
    String str1 = "Hello world.";
    String str2 = "Hello world.";

    if (str1 == str2)
        System.out.print("str1 == str2\n");
    else
        System.out.print("str1 != str2\n");

    if(str1.equals(str2))
        System.out.print("str1 equals to str2\n");
    else
        System.out.print("str1 doesn't equal to str2\n");

    String str3 = new String("Hello world.");
    String str4 = new String("Hello world.");

    if (str3 == str4)
        System.out.print("str3 == str4\n");
    else
        System.out.print("str3 != str4\n");

    if(str3.equals(str4))
        System.out.print("str3 equals to str4\n");
    else
        System.out.print("str3 doesn't equal to str4\n");
}

Когда выполняется первая строка кода String str1 = "Hello world.", строка \Hello world." , и переменная str1 относится к ней. Другая строка "Hello world." не будет создана снова, когда следующая строка кода будет выполнена из-за оптимизации. Переменная str2 также относится к существующей ""Hello world.".

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

Когда выполняется код String str3 = new String("Hello world."), создается новый экземпляр строки с контентом "Hello world.", на который ссылается переменная str3. Затем снова создается другой экземпляр строки с контентом "Hello world." и упоминается str4. Поскольку str3 и str4 относятся к двум различным экземплярам, ​​они не идентичны, но их контент одинаковый.

Следовательно, вывод содержит четыре строки:

Str1 == str2

Str1 equals str2

Str3! = str4

Str3 equals str4

Ответ 10

Вы должны использовать string равно для сравнения двух строк для равенства, а не оператора ==, который просто сравнивает ссылки.

Ответ 11

== оператор сравнивает ссылку на объект в Java. Вы можете использовать метод equals строк.

String s = "Test";
if(s.equals("Test"))
{
    System.out.println("Equal");
}

Ответ 12

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

Пример:

String a = "name";

String b = "name";

if(a == b) и (a.equals(b)) вернет true.

Но

String a = new String("a");

В этом случае, if(a == b) вернет false

Так что лучше использовать оператор .equals...

Ответ 13

Обычно .equals используется для сравнения Object, где вы хотите проверить, имеют ли два Objects одинаковое значение.

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

Ответ 14

Оператор == - это простое сравнение значений.
Для ссылок на объекты (значения) являются (ссылки). Таким образом, x == y возвращает true, если x и y ссылаются на один и тот же объект.

Ответ 15

@Melkhiah66 Вы можете использовать метод equals вместо метода '==' для проверки равенства. Если вы используете intern(), то он проверяет, находится ли объект в пуле, если он присутствует, а затем возвращает равным другим неравным. метод equals внутренне использует hashcode и получает требуемый результат.

public class Demo
{
  public static void main(String[] args)
  {
              String str1 = "Jorman 14988611";
    String str2 = new StringBuffer("Jorman").append(" 14988611").toString();
    String str3 = str2.intern();
    System.out.println("str1 == str2 " + (str1 == str2));           //gives false
    System.out.println("str1 == str3 " + (str1 == str3));           //gives true
    System.out.println("str1 equals str2 " + (str1.equals(str2)));  //gives true
    System.out.println("str1 equals str3 " + (str1.equals(str3)));  //gives true
  }
}

код >

Ответ 16

Я знаю, что это старый вопрос, но вот как я его смотрю (я считаю очень полезным):

Технические пояснения

В Java все переменные являются либо примитивными типами, либо ссылками.

(Если вам нужно знать, что такое ссылка: "Переменные объекта" - это просто указатели на объекты. Таким образом, с Object something = ... что-то действительно является адресом в памяти (числом).)

== сравнивает точные значения. Поэтому он сравнивает, совпадают ли примитивные значения или ссылки (адреса) одинаковы. Вот почему == часто не работает на Strings; Строки - это объекты, а выполнение == по двум строковым переменным просто сравнивается, если адрес совпадает с адресом в памяти, как указывали другие. .equals() вызывает метод сравнения объектов, который будет сравнивать фактические объекты, указанные ссылками. В случае с строками он сравнивает каждый символ, чтобы увидеть, равны ли они.

Интересная часть:

Так почему же == иногда возвращает true для строк? Обратите внимание, что Строки неизменяемы. В вашем коде, если вы делаете

String foo = "hi";
String bar = "hi";

Так как строки неизменяемы (когда вы вызываете .trim() или что-то, оно создает новую строку, не изменяя исходный объект, на который указывает память), вам не нужны два разных объекта String("hi"). Если компилятор является интеллектуальным, байт-код будет читать только один объект String("hi"). Так что если вы делаете

if (foo == bar) ...

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

Примечание. Если вы сделаете что-то вроде baz = new String(bar), компилятор все равно может понять, что это одно и то же. Но главное, когда компилятор видит буквальные строки, он может легко оптимизировать те же строки.

Я не знаю, как это работает во время выполнения, но я предполагаю, что JVM не ведет список "живых строк" ​​и проверяет, существует ли одна и та же строка. (например, если вы дважды читаете строку ввода, а пользователь вводит один и тот же ввод дважды, он не будет проверять, совпадает ли вторая строка ввода с первой, и указывать их на одну и ту же память). Это спасло бы кучу памяти, но это настолько незначительно, что накладные расходы не стоят. Опять же, проще всего компилятор оптимизировать литералы.

Там у вас есть... подробное объяснение для == vs. .equals() и почему это кажется случайным.

Ответ 17

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

Ответ 18

Кто-то сказал в сообщении выше, что == используется для int и для проверки нулей. Он также может использоваться для проверки булевых операций и типов char.

Будьте очень осторожны и дважды проверьте, что вы используете char, а не строку. например

    String strType = "a";
    char charType = 'a';

для строк, которые вы затем проверили бы Это было бы правильно

    if(strType.equals("a")
        do something

но

    if(charType.equals('a')
        do something else

будет неправильным, вам нужно будет сделать следующее

    if(charType == 'a')
         do something else

Ответ 19

a==b

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

• Сравнение с тем, если ссылка null.

• Сравнение двух значений перечисления. Это работает, потому что для каждой константы enum существует только один объект.

• Вы хотите знать, связаны ли две ссылки с одним и тем же объектом

"a".equals("b")

Сравнивает значения для равенства. Поскольку этот метод определен в классе Object, из которого выведены все остальные классы, он автоматически определяется для каждого класса. Тем не менее, он не выполняет интеллектуальное сравнение для большинства классов, если класс не переопределяет его. Он был определен значимым образом для большинства базовых классов Java. Если он не определен для класса (пользователя), он ведет себя так же, как ==.

Ответ 20

Используйте Split, а не токенизатор, он обязательно обеспечит u точный вывод например:

string name="Harry";
string salary="25000";
string namsal="Harry 25000";
string[] s=namsal.split(" ");
for(int i=0;i<s.length;i++)
{
System.out.println(s[i]);
}
if(s[0].equals("Harry"))
{
System.out.println("Task Complete");
}

После этого я уверен, что вы получите лучшие результаты.....