字符串。等于和==

这段代码将一个字符串分离为令牌，并将它们存储在一个字符串数组中，然后将一个变量与第一个home…为什么它不工作?

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;
i++;
}


//System.out.println (usuario);


if ((datos[0] == usuario)) {
System.out.println("WORKING");
}
}
918602 次浏览
小开
最佳答案

使用string.equals(Object other)函数比较字符串，而不是==操作符。

该函数检查字符串的实际内容，==操作符检查对对象的引用是否相等。请注意，字符串常量通常是“内嵌”的，因此两个具有相同值的常量实际上可以与==进行比较，但最好不要依赖于此。

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

注意:比较是在'usuario'上完成的，因为这在你的代码中保证非空，尽管你仍然应该检查你实际上在datos数组中有一些令牌，否则你会得到一个数组越界异常。

小开

而不是

datos[0] == usuario

使用

datos[0].equals(usuario)

==比较变量的引用，.equals()比较你想要的值。

小开

您应该使用字符串=来比较两个字符串是否相等，而不是使用operator ==来比较引用。

小开

值得注意的是，在某些情况下，使用“==”操作符可以得到预期的结果，这是由于Java处理字符串的方式 -字符串字面量在编译过程中被实习(参见String.intern()) -因此，当你在两个类中编写"hello world"并将这些字符串与“==”进行比较时，你可以得到结果:true，这是根据规范;当你比较相同的字符串(如果他们有相同的值)，当第一个是字符串字面量(即。通过"i am string literal"定义)，第二个在运行时ie中构造。对于像new String("i am string literal")这样的“new”关键字，==(相等)操作符返回false，因为它们都是String类的不同实例。

唯一正确的方法是使用#EYZ0 -> datos[0].equals(usuario)。 ==表示仅当两个对象是相同的对象实例(即。内存地址相同)

更新: 01.04.2013我更新了这篇文章，下面的评论是正确的。最初我声明实习(String.intern)是JVM优化的副作用。虽然它确实节省了内存资源(这就是我所说的“优化”)，但它是语言的主要特征

小开
如果在将字符串插入数组之前调用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");
}
小开

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是两个具有相同内容的不同字符串。因此，这里的表达式(abc == xyz)是false，而(abc.equals(xyz))是true。

希望你能理解==和<Object>.equals()之间的区别

谢谢。

小开

让我们分析下面的Java，来理解string的恒等式:

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."的string的另一个实例，并由 # EYZ0。因为str3和str4引用了两个不同的实例，所以它们并不相同，但它们是相同的

.内容相同

因此，输出包含四行:

Str1 == str2


Str1 equals str2


Str3! = str4


Str3 equals str4
小开

==操作符比较Java中对象的引用。你可以使用string的equals方法。

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

如果你要比较字符串的任何赋值，即原始字符串，"=="和.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操作符…

小开
使用Split而不是tokenizer，它肯定会为你提供准确的输出 如:< / p > 
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");
}

在此之后，我相信你会得到更好的结果.....

小开

通常，.equals用于Object的比较，您希望验证两个Objects是否具有相同的值。

==作为参考比较(两个Objects在堆上是相同的Object) &检查Object是否为空。它还用于比较基本类型的值。

小开

==运算符是一个简单的值比较 对于对象引用，(值)就是(引用)。因此，如果x和y引用同一个对象，则x == y返回true

小开
你可以使用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
}
}

> < /代码

小开

我知道这是一个老问题，但我是这样看的(我觉得很有用):

技术的解释

在Java中，所有变量都是原始类型或参考文献。

(如果你需要知道什么是引用:“对象变量”只是指向对象的指针。，所以对于Object something = ...，某些东西实际上是内存中的一个地址(一个数字)。)

==比较准确的值。因此，它比较原始值是否相同，或者引用(地址)是否相同。这就是为什么==经常在字符串上不起作用;字符串是对象，对两个字符串变量执行==只是比较内存中的地址是否相同，就像其他人指出的那样。.equals()调用对象的比较方法，它将比较引用所指向的实际对象。在字符串的情况下，它比较每个字符，看它们是否相等。

# EYZ0:

那么为什么==有时会为字符串返回true呢?注意字符串是不可变的。在你的代码中

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

由于字符串是不可变的(当您调用.trim()或其他东西时，它会生成一个新的字符串，而不是修改内存中指向的原始对象)，因此实际上不需要两个不同的String("hi")对象。如果编译器是智能的，字节码将只生成一个String("hi")对象。所以如果你这样做

if (foo == bar) ...

之后，它们指向同一个对象，返回true。但你很少会这么想。相反，你要求用户输入，这是在内存的不同部分创建新的字符串，等等。

请注意:如果你执行类似baz = new String(bar)的操作，编译器可能仍然会认为它们是相同的东西。但重点是，当编译器看到字面值字符串时，它可以很容易地优化相同的字符串。

我不知道它在运行时是如何工作的，但我假设JVM没有保存一个“活动字符串”列表，并检查是否存在相同的字符串。(例如，如果你读取一行输入两次，用户输入相同的输入两次，它不会检查第二个输入字符串是否与第一个输入字符串相同，并将它们指向相同的内存)。这将节省一些堆内存，但它是如此微不足道，开销是不值得的。同样，重点是编译器很容易优化文字字符串。

你知道了……== vs. .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()要便宜得多(一个指针比较而不是一个循环)，因此，在适用的情况下(即您可以保证只处理实习字符串)，它可以提供重要的性能改进。然而，这种情况很少见。

小开

满足Jorman

Jorman是一个成功的商人，他有两套房子。

enter image description here

但其他人并不知道。

还是那个乔曼吗?

当你问麦迪逊街或伯克街的邻居时，他们唯一能说的就是:

enter image description here

仅从住所来看，很难确定是同一个人。因为他们是两个不同的地址，所以很自然地假设他们是两个不同的人。

所以它会说datos[0]==usuario是假的，因为它只有比较地址。

一个救援的调查员

如果我们派个调查员去呢?我们知道是同一个乔曼，但我们需要证明。我们的警探会仔细检查身体的各个方面。通过彻底的调查，代理人将能够得出结论，是否是同一个人。让我们看看它在Java术语中的情况。

下面是String的equals()方法的源代码:

enter image description here

它逐个字符地比较字符串，以便得出它们确实相等的结论。

因此，datos[0].equals(usuario)将返回true，因为它执行了逻辑比较。

小开

.equals()将检查两个字符串是否具有相同的值，并返回boolean值，其中==操作符将检查两个字符串是否为同一对象。

小开
有人在更高的帖子上说==用于int和检查空值。 它也可以用来检查布尔操作和字符类型 但是要非常小心，仔细检查你使用的是char类型而不是String类型。 例如

    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
小开 
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.
小开

# EYZ0

比较引用，而不是值。在对象引用中使用==通常仅限于以下情况:

  1. 比较一个引用是否为null。

  2. 比较两个enum值。这是因为每个enum常量只有一个对象。

  3. 您想知道两个引用是否指向同一个对象

# EYZ0

比较值是否相等。因为这个方法是在Object类中定义的，所有其他类都是从这个类派生出来的，所以它是为每个类自动定义的。但是，它不会对大多数类执行智能比较，除非类重写它。对于大多数Java核心类，它都以一种有意义的方式定义。如果它不是为(用户)类定义的，那么它的行为与==相同。


提交答案