如何比较Java中的string？
我一直在使用==运算符来比较我所有的string。 但是，我遇到了一个bug，把其中一个改成了.equals() ，然后修复了这个bug。
是==不好？ 什么时候该用，不该用？ 有什么不同？
==testing引用是否相等（不pipe它们是否是同一个对象）。
.equals()testing值是否相等（不pipe它们在逻辑上是否相等）。
Objects.equals（）在调用.equals()之前检查是否为null，所以您不必（从JDK7开始，也可在Guava中使用 ）。
因此，如果要testing两个string是否具有相同的值，则可能需要使用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 // ... but you should really just call Objects.equals() Objects.equals("test", new String("test")) // --> true Objects.equals(null, "test") // --> false
你几乎总是要使用Objects.equals() 。 在罕见的情况下，你知道你正在处理internedstring，你可以使用== 。
从JLS 3.10.5开始。 string文字 ：
而且，一个string文字总是引用类
String的同一个实例。 这是因为string文字 – 或者更一般地说，是常量expression式（ §15.28 ）的值的string – 被“ interned ”，以便使用方法String.intern共享唯一的实例。
类似的例子也可以在JLS 3.10.5-1中find。
==testing对象引用， .equals()testingstring值。
有时它看起来好像==比较值，因为Java会做一些幕后的工作，以确保相同的内联string实际上是同一个对象。
例如：
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";
但要小心空位！
==很好地处理nullstring，但是从空string调用.equals()会导致exception：
String nullString1 = null; String nullString2 = null; // Evaluates to true nullString1 == nullString2; // Throws an Exception nullString1.equals(nullString2);
==比较对象引用。
.equals()比较string值。
有时==会给出比较string值的错觉，如下例所示：
String a="Test"; String b="Test"; if(a==b) ===> true
这是因为当您创build任何string文字时，JVM首先在string池中search该字面值，如果find匹配项，则会将相同的引用赋予新的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将在堆中创build，该引用将被赋予给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()总是更好。
希望这会有所帮助。
==运算符检查两个string是否完全相同。
.equals()方法将检查两个string是否具有相同的值。
在Java中的string是不可变的，这意味着每当你试图改变/修改string，你会得到一个新的实例。 您不能更改原始string。 这已经完成，以便这些string实例可以被caching。 一个典型的程序包含大量的string引用，caching这些实例可以减less内存占用，提高程序的性能。
当使用==运算符进行string比较时，您并不比较string的内容，而是实际比较内存地址，如果两者相等，则返回true，否则返回false。 而在string中等于string内容。
所以问题是如果所有的stringcaching在系统中如何返回false，而等于返回true。 那么这是可能的。 如果你创build了一个像String str = new String("Testing")的新string，那么即使caching中已经包含了一个具有相同内容的string，你最终也会在caching中创build一个新的string。 简而言之， "MyString" == new String("MyString")将始终返回false。
Java还谈到了函数intern（），它可以用在string上，使其成为caching的一部分，所以"MyString" == new String("MyString").intern()将返回true。
注意：==运算符要快得多，等于只是比较两个内存地址，但需要确保代码不会在代码中创build新的String实例，否则会遇到错误。
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()方法对内容进行逐个字符的比较。
当为a和b调用new时，每一个都会得到一个指向string表中"foo"的新引用。 引用是不同的，但内容是相同的。
是的，这很糟糕…
“==”表示您的两个string引用是完全相同的对象。 您可能已经听说过这种情况，因为Java保留了一个字面表（它确实），但情况并非总是如此。 一些string以不同的方式加载，由其他string等构成，所以您绝不能假定两个相同的string存储在相同的位置。
等于你真正的比较。
Java有一个String池，在这个池下Javapipe理String对象的内存分配。 请参阅java中的string池
当你使用==运算符检查（比较）两个对象时，会发生什么情况，它会将地址相等比较到string池中。 如果两个String对象具有相同的地址引用，则返回true否则返回false 。 但是如果你想比较两个String对象的内容，那么你必须重写equals方法。
equals实际上是Object类的方法，但被重写到String类中，并给出新的定义来比较对象的内容。
Example: stringObjectOne.equals(stringObjectTwo);
但是介意它尊重String的情况。 如果你想不区分大小写比较，那么你必须去String类的equalsIgnoreCase方法。
Lets See: 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
是的， ==不好比较string（任何对象真的，除非你知道它们是规范的）。 ==只是比较对象引用。 .equals()testing是否相等。 对于string，通常他们会是一样的，但是，正如你发现的那样，并不总是保证。
==比较Java中的对象引用，对于String对象也不例外。
为了比较对象的实际内容（包括String ），必须使用equals方法 。
如果两个使用== String对象的比较结果是true ，那是因为String对象被拦截，并且Java虚拟机有多个引用指向同一个String实例。 不要期望将包含相同内容的一个String对象与使用==另一个String对象比较为true 。
.equals()比较类中的数据（假定函数已经实现）。 ==比较指针的位置（对象在内存中的位置）。
==如果两个对象（NOT TALKING ABOUT PRIMITIVES）都指向SAME对象实例，则返回true。 如果两个对象在Java中包含相同的数据equals() Versus == ，那么.equals()返回true
这可能会帮助你。
==执行引用相等检查，2个对象（本例中是string）是否指向内存中的同一个对象。
equals()方法将检查2个对象的内容或状态是否相同。
很明显， ==比较快，但是如果你只是想知道2个String是否保存相同的文本，在很多情况下会（假）给出错误的结果。
当然推荐使用equals()方法。
不要担心表演。 有些事情鼓励使用String.equals() ：
-
String.equals()实现首先检查引用是否相等（使用==），如果2个string是通过引用相同的，则不执行进一步的计算！ - 如果2个string引用不相同，则
String.equals()将接下来检查string的长度。 这也是一个快速操作，因为String类存储string的长度，不需要计算字符或代码点。 如果长度不同，不再进行检查，我们知道它们不可能相等。 - 只有当我们知道了这两个string的内容时，才会真正比较这两个string的内容，这将是一个短暂的比较：如果我们发现一个不匹配的字符（并不是所有的字符都会被比较） ），将不会检查更多的字符。
当所有事情都说完之后，即使我们保证这些string是实习生，使用equals()方法仍然不是人们想象的开销，绝对是推荐的方法。 如果你想要有效的引用检查，那么在语言规范和实现保证的地方使用枚举，即相同的枚举值将是同一个对象（通过引用）。
我同意来自zacherates的回答。
但是你可以做的是在你的非文字string上调用intern（）。
从zacherates例子：
// ... but they are not the same object new String("test") == "test" ==> false
如果你实习的非文字string相等是真的
new String("test").intern() == "test" ==> true
如果你和我一样，当我第一次开始使用Java的时候，我想用“==”运算符来testing两个String实例是否相等，但不pipe好坏，这不是用Java来完成的。
在本教程中，我将演示几种不同的方式来正确比较Javastring，从大部分时间使用的方法开始。 在这个Java String比较教程的最后，我还将讨论为什么比较Javastring时“==”运算符不起作用。
选项1：Javastring与equals方法的比较大多数情况下（可能是95％的时间）我将string与Java String类的equals方法进行比较，如下所示：
if (string1.equals(string2))
这个String equals方法查看两个Javastring，如果它们包含完全相同的string，则它们被认为是相等的。
用equals方法来看一个快速的string比较示例，如果运行下面的testing，两个string将不会被认为是相等的，因为字符不完全相同（字符的情况不同）：
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.") }
但是，当两个string包含完全相同的string时，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方法进行string比较
在一些string比较testing中，你会忽略string是大写还是小写。 如果要以不区分大小写的方式testingstring是否相等，请使用String类的equalsIgnoreCase方法，如下所示：
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方法
还有第三种不太常用的比较Javastring的方法，那就是用String类的compareTo方法。 如果两个string完全相同，则compareTo方法将返回值0（零）。 下面是这个String比较方法的一个简单例子：
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语言在基本的Java Object类中包含了一个equals方法。 无论何时创build自己的对象，并且想要提供一种方法来查看对象的两个实例是否“相等”，则应该在类中重写（并实现）这个equals方法（与Java语言提供的方式相同String equals方法中的这种相等/比较行为）。
你可能想看看这个==，.equals（），compareTo（）和compare（）
function：
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())); }
testing：
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);
==运算符检查两个引用是否指向同一个对象。 .equals()检查实际的string内容（值）。
请注意.equals()方法属于Class Object （所有类的超级类）。 您需要根据您的类需求来覆盖它，但对于已经实现的string，它会检查两个string是否具有相同的值。
-
情况1
String s1 = "StackOverflow"; String s2 = "StackOverflow"; s1 == s2; //true s1.equals(s2); //true原因：创build为非null的string文本存储在堆的permgen区域的String池中。 所以s1和s2都指向池中的同一个对象。
-
案例2
String s1 = new String("StackOverflow"); String s2 = new String("StackOverflow"); s1 == s2; //false s1.equals(s2); //true原因：如果使用new关键字创buildString对象，则将单独空间分配给堆。
==比较对象的引用值，而java.lang.String类中的equals()方法比较String对象（与另一个对象）的内容。
我认为，当你定义一个String你定义一个对象。 所以你需要使用.equals() 。 当使用原始数据types时，您使用==但是使用String （以及任何对象），您必须使用.equals() 。
总是==运算符用于对象引用的比较 ，其中作为String类的.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)
equals()方法存在于java.lang.Object类中，并期望检查对象状态的等价性。 这意味着，对象的内容。 ==运算符期望检查实际的对象实例是否相同。
例
考虑两个不同的引用variablesstr1和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都指向两个不同的对象，即使它们都共享相同的string内容。 这是因为每次创build一个新的对象时都会有new String() 。
您也可以使用compareTo()方法来比较两个string。 如果compareTo结果为0，则两个string相等，否则比较的string不相等。
==比较引用，并不比较实际的string。 如果使用new String(somestring).intern()创build了每个string，则可以使用==运算符来比较两个string，否则只能使用equals（）或compareTo方法。
所有对象保证有一个.equals()方法，因为Object包含一个方法.equals() ，返回一个布尔值。 如果需要进一步的定义定义，子类的工作就是覆盖这个方法。 没有它（即使用== ）只有内存地址检查两个对象之间是否相等。 string重写这个.equals()方法，而不是使用内存地址，它返回字符级别的string比较相等。
需要注意的是，string存储在一个池中，所以一旦创build了string，它就永远存储在同一地址的程序中。 string不会改变，它们是不可改变的。 这就是为什么使用常规string连接是一个坏主意，如果你有一个严重的string处理量。 相反，你会使用提供的StringBuilder类。 记住指向这个string的指针可以改变，如果你有兴趣看看两个指针是否相同==将是一个好方法。 弦乐本身不。
在Java中，当使用“==”运算符比较两个对象时，它会检查对象是否指向内存中的相同位置。 换句话说，它检查2个对象名是否基本上是对同一个内存位置的引用。
Java String类实际上覆盖了Object类中默认的equals（）实现 – 并且覆盖了该方法，因此它只检查string的值，而不检查它们在内存中的位置。 这意味着如果调用equals（）方法来比较2个String对象，那么只要实际的字符序列相等，这两个对象都被认为是相等的。
==运算符检查两个string是否完全相同。
.equals()方法检查两个string是否具有相同的值。
