Строка.равно против == [дубликат]

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

Йорман является успешным бизнесменом и имеет 2 дома.

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

Это тот же Йорман?

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

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

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

следователь на помощь

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

вот исходный код строки equals() способ:

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

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

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

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

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

на abc и xyz, оба относятся к одному и тому же String"Awesome". Отсюда и выражение (abc == xyz) is 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 где (abc.equals(xyz)) и true.

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

спасибо.

вместо

datos[0] == usuario

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

datos[0].equals(usuario)

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

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

.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() (сравнение с одним указателем вместо цикла), таким образом, в ситуациях, когда это применимо (т. е. вы можете гарантировать, что имеете дело только с интернированными строками), это может привести к значительному повышению производительности. Однако такие ситуации встречаются редко.

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

обратите внимание, что .метод equals () принадлежит объекту класса (суперкласс всех классов). Вам нужно переопределить его в соответствии с вашим требованием к классу, но для 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.

Он также будет работать, если вы называете 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");    
}

давайте проанализируем следующую 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." is созданный снова и на который ссылается str4. Так как str3 и str4 обратитесь к двум разным экземплярам, они не идентичны, но их содержание же.

поэтому вывод содержит четыре строки:

Str1 == str2

Str1 equals str2

Str3! = str4

Str3 equals str4

вы должны использовать строки равен чтобы сравнить две строки для равенства, не оператор == который просто сравнивает ссылки.

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

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

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

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

---

техническая объяснениями

в Java все переменные либо примитивные типы или ссылки.

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

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

---

самое интересное:

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

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

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

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

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

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

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

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

пример:

String a = "name";

String b = "name";

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

но

String a = new String("a");

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

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

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

кто-то сказал на пост выше, что == используется для int и для проверки значений null. Он также может быть использован для проверки логических операций и типов 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

a==b

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

1. сравнение, чтобы увидеть, если ссылка null.

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

3. вы хотите знать, если две ссылки на тот же объект

"a".equals("b")

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

используйте разделение, а не токенизатор,он, безусловно, обеспечит точный выход 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");
}

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