The fourth most viewed question on StackOverflow, with over 3.7 million views over the years is how do I compare strings in Java? So yeah, the comparison between strings is special. But in general, it is interesting. How can I compare two objects with each other? and Java knows two different comparisons, two different kinds of comparisons comparisons. And so yeah, you have two different approaches to compare two strings, or in general, two objects with each other.

And we want to take a look at both. So the first approach is the equality operator. It is written with two equal signs and The equality operator compares two references with each other. We take a look what what is the house Exactly. And the second one is the equals. In a call of the equals method of an object, so the equals method is part of the class object.

And in Java every every kind of class is extending the object class. So every every object every kind of, of data type in Java has the equals method because equals method is part of the object class. Okay? And with the equals method, you check the content of two objects, so you compare the content, not the references of it. So let's have a look how Java works. As I said, with with the equality operator, you can compare two reference with each other if they are pointing on the same object on the heap.

So let's take a look what this means. I have created an example. In line three, we are creating an object with a string with the content hello world, and an reference string as one. So as one is pointing to an object with the content hello world. And if you create an object in Java, every created object is stored in the heap of your computer from your working storage. Yes.

All right. So yeah, just call credit. An object in the heap I call it string one, it's a portal name with the content hello world and as one is a reference to this object, so s one is pointing to this object in line four, I create another reference called string as to and say as two equals as one. And what it does is that as as two is pointing to the same object as as one, okay, so, as you can see in Java, on the left side, there are only references, which are pointing to objects or to other yeah to two objects. Tonight, we will see it later. And the objects are in the heap now In this case, after computing line four, it looks like that, that s one and s two is pointing on the same object.

So it's the theft the reference is the same. So if you compare the references with the equal operator, it says true. So as one equal operator as two is true, okay, because as one and as two as pointing on the same to the same object, so the reference is the same. So, if we continue with our code, and we write as two equals new string, hello world, what what happens in the heap is it creates another a second Object Soto called string two with the same content, but the object is another one. And so, we have now we have two different objects string one and object string two, but they have the same the same content, but are different objects. And with this call in line to the reference s two isn't pointing to object one anymore, but now it is pointing to object to.

So it looks like this. And now, if I am checking with the equal equality operator, if s one and s two is the same reference, it says false. Yeah. Okay. It makes sense because they are not pointing on the same object. anymore.

And it is the content of the object is Yeah, doesn't matter here, it is all only looking at the references. If you want to compare the content of the objects, you have to use the equals method. So that's the second approach to compare strings in Java or objects. Now, as I said, there are two different kinds of comparison and now we are looking at the second approach. The second approach takes a look at the content of two objects. And in this case, if we are looking at our example from from that we just saw, so we create as one and as two points on the same object like as one The content is the same for sure.

As one equals as two is true, clear. And if I create, then another string object with also HelloWorld is content and I create, or I asked is as one equals as two. And it says also true, because the content is the same. Yeah, let's have a look at what what is happening here. So we in our case, we are using the string class. Go to navigate, open type.

Then we type string, Java string. And there must be an equals method. You can go Quick outline. And then you can type equals and then you see, okay, this is the implementation of the equals method from class string. Let's have a quick look at object we go to navigate open type object. And as you can see, object s equals two.

Yeah, and that's the default implementation equals. So, it compares the instance where the equals method is called. And then it compares is this instance, the same reference as the given option. Correct. So it both references are pointing on the same object if yes, so equals is also true. So the content is the same.

Clear. And, yeah, this kind of this method is an overriding this equals method from object. And it's come it's a bit confusing, but it compares the value of the string. And value. You can see it here. value as the value is used for character storage.

So in this variable the text value of the string is stored. And in the equals method, the value of the instance and the value of an object. In this case, an object is a string. So a string is cast. An object is cast. to string on and then the value from this one and this is compared with each other.

So, yeah, you will see the equals method is looking at the content of objects. If you are writing an own own data type you can you can override the equals method and you can say, or you can define when two to two different objects are the same content regarding the content by overriding the equals method, okay. So, beware of my pointer exceptions. You if you are having data types, like strings or any kind of objects that are not primitives, You can initialize them by with with Niall. And if you are asking or checking the references is a three equals as for or the equal for equality operator. It's a it's true.

Yeah, for sure imports are not references. But if you are looking at F three dot equals as four, it gets my pointer exception. So why at three is nine and you you aren't allowed to invoke methods on on NIH. If you try to you get an NIH point exception. There is later on I think the question number nine This is handling with nine point exceptions and how to avoid and how to fix it. So let's have a look later on this issue.

But for for now. You have to be aware you can't always call the equals method on each object because the object may be nice. So, yeah, be aware of the nine point exception. In this case. Since Java version seven there is a class called objects. And this class has a equals method on its own, and it's an i pointer exception safe I call it y.

If it checks if A is now so let's have a look how it works. You ask the class is object a and object B are the reference from from type object a and reference of type object called B. Is it the same, or equals is the essence content. So it says, Okay, if A is pointing to the same object as B, it is true for sure. If it's not the same reference, then this is one wall, then it evaluates this expression. And first it take a look if A is is not equal to NY.

And if this is the case, then a dot equals b is called is a null. And then this one isn't called anymore. Yeah, to get rid of the nine point exception, and, yeah, so you'll see if you want to use the equals method, and you don't want to get an Aponte exception Or you, you don't want to, to have the the dangerous of an eye upon exception, use the objects fast objects dot equals and if both objects in it, and it is now a pointer exception safe. As you can see, comparing strings with each other is a bit special and a bit confusing at the beginning. And that's why I think the question is how do I compare strings in Java with each other and not how do I compare objects with each other because in in the case of strings, there is a bit confusion because of the string pool is a so called string pool.

What is the string pool? You can initialize strings in two different ways. Like you can write it like in a line to for example, without using an constructor, and you can create and string like in line three with a constructor. If you are using the expression without constructor, you get an string with the same with the same content as in the in the seven. But if you are using this one, they are the string object you get. The reference is pointing to an string object that isn't in the heap, but it is in the string so called string foo.

So every time you create while you are using suction string without using the constructor, Java is creating an object of class string And lays it in the string pool for reusability. So, if you are using later on the same string without calling the constructor, Java looks in the string pool and sees, okay, there's already a string with this content. So, I could reuse it and I give it back to the same reference. So, if you are writing s five and six, they are they are pointing to the same object worth in the string quiz. So yeah, if you if you if you think you are using for example 100 times hello world, why whatever, but you are using it. And if they are wearing a string pool, Java had Chava had to To create 100 times an object of types string with the same content.

And with the string pool, it is it has only created one object and gave away 100 reference to the same object. So that's why the string pool or that's the background of the string pool. So yeah, by calling as five and six, both the same way, if we are we if we compare those, the reference, we get true as reside. So they are pointing to the same object within the string pool. But you can explicitly create a new object on the heap and you can say I don't want to use the object of the string pool. Want my own object.

And if you do so, or if you want to do so, you should use the constructor of class string. And if you do, if you write new string hello world, Java don't use doesn't use the string pool. It's used the constructor and creates a new string object on the heap with the same content like the object in the string pool. But that's the reason why, if you compare the reference between as six and seven, it says false. So that's the special special thing regarding the strings. So if you don't know the string pool, and then you you would think, okay, I create an object here create an object There are so the two different objects.

Why is says reference true Why? Why the reference the same? The answer is because Java is using a string pool. And now you are aware of this kind of comparison and you understand why this is the same. That's the special thing about the string pool. All right, that's so far the comparison between two strings in Java or in general is a comparison between two objects in Java.

Let's have a look at the next question.