[MUSIC]

Hi.

I'm Craig and I'm a developer.

Now we've all been there.

We think we understand the basics of a programming language and

then we encounter a line of code that blows our mind.

And it makes us question everything we thought we knew up until that point.

Well a huge culprit of that sort of experience is strings in Java.

Strings have several characteristics about them that, when combined,

can definitely go cross-eyed with confusion.

And you'll find yourself not alone in your confusion.

Hitting the search engines, you'll find hundreds of thousands of questions about

them and why they behave the way they do.

I thought that this format would be a good way to go and

explore why strings seem to be so mysterious.

And try to demystify and

expose the common misunderstandings that happen when we use string in our code.

Are you ready?

Let's dive in.

Okay. So I've written a little program here

called Thing.java.

And it's gonna help us explore some concepts about strings.

Now I've added a method here called explore.

And it takes an assumption about what we are going to be exploring and

an expression.

The expression is expected to always be true.

It will generate a result and let us know if our assumption is correct.

So let's get right into some of those explorations.

We have explored equality a little bit already.

And we know that when we want to compare primitives together we can use the double

equal sign.

So let's make a couple primitives.

So we'll have int firstNumber equals 12 and int secondNumber equals 12.

Hey, let's go ahead and call our explorer method.

That's what it looks like.

We say primitives use double equals.

Okay, and then the expression that we wanna say,

wanna say is firstNumber use double equals to the secondNumber.

All right, well let's just run this and

make sure that our explorer method's working.

So we'll say clear and then javac.

We compile Thing.Java, and then we're gonna run it.

Cool.

So we get a yea.

So we know that it's working.

So that's primitives, but what about objects?

Let's create two brand new objects exactly the same way.

Now since we didn't change anything, they must be equal, right?

So, let's make two new objects.

We'll say Object, firstObject equals new Object.

And secondObject equals new Object.

Okay, so let's explore that.

Well let's say, explore objects work just like primitives.

So we should be able to use the double equals, right?

[BLANK_AUDIO]

Let's run that.

Okay, and we got a what.

you're assumption is incorrect.

Our first what.

So objects work a little bit different.

When we create an object, the variable represents an object reference.

Now you can use double equals for objects, but what that's saying is that

the object references are actually referring to the same object.

Let's explore that.

So, first of all, let's fix our exploration statement here,

our assumption, and let's say, Objects, references use double equals to check

if they refer to the same object in memory.

It's gonna wrap seemingly equal objects are not equal.

So we can actually use the not equals sign.

So let's do that.

I know, let's go ahead and make a new object that refers to the first object.

So we'll just say Object, the sameObject equals, and

we'll just literally put the object reference in there.

So now let's ex, let's do another exploration.

Let's say, let's say explore object references

must refer to the same object to use double equals.

So, firstObject equals sameObject.

Let's go ahead and run that and see.

There we go, two YAYs.

So this holds true for all objects.

Now the thing to remember is this,

strings are objects, everything inherits from objects.

So double equals only works if the variable is referring to the same object.

So you might have seen some double equals seemingly work for strings.

Let's explore that just a bit.

We'll make a new string, firstString this equals, [INAUDIBLE] my name and

we'll say, String secondString is equal to Craig.

And let's just go ahead and we'll say explore

strings are objects and work like objects.

So therefore, they're two separate objects, so they're not the same.

So we'll say firstString is not equal to secondString.

Let's go ahead and run that.

And we get a what.

Huh, how could those two be equal?

Aren't they two completely different objects?

What is the deal?

I thought I understood how this works, and now I'm not so sure.

Ok, so

the good news here is you're not going crazy, those are actually the same object.

So here's the thing, when you create a string like that, you know,

putting it in double quotes?

We're creating what is known as a string literal.

Now since strings are immutable which means, if you remember,

they can't be changed, the compiler does some tricks to optimize.

Since it knows the string won't change it just creates a single instance of that

string and makes all variables refer to that single instance.

It keeps these special references in a special place in memory called

the string pool.

So it's essentially like we saw in the previous object equality, right?

They're pointing to the same thing.

So let's fix our exploration here.

String literals are actually referring

to the same object, all right.

So at compile time that becomes the same object.

So we're gonna put double equals there.

Okay.

And let's add a new one that uses a dynamic string,

one that isn't there at compile time.

So you can kind of imagine this as input coming in from the user.

Now a handy way to make sure that we're creating a unique string is

by using its constructor that actually takes a string.

So let's take a look at that.

So let's say, string differentString is equal to a new String.

They have the same, what seems like to be the same value, so let's do this.

All right, this exploration string objects

that contain the same characters but

point to different objects cannot use double equals.

So let's prove that really quick.

FirstString does not equal a differentString.

Okay, so let's check those assumptions.

Awesome, those are both YAY.

So, one final trick that you might see used is a process called string interning.

You can actually take a user imputed string and add it to the same string pool,

and you do that by using a method on stings called intern.

So let's explore that, just for a quick second.

So let's add a string called anotherString.

And we use that same constructor method, okay.

And let's make a new assumption and we'll say string interning

adds to the same String Pool where literals live,

so you get back the same reference, if it exists.

Okay, so we can say anotherString and

if we do .intern is equal, now we can use double equals.

Let's go ahead and make sure that that works.

Awesome.

So because you almost always are checking object equality and

not concerning yourself with object reference equality,

this is why you almost always should use the equals method, like this.

[BLANK_AUDIO]

And this is true of all objects, so

all objects should use equals to check equality.

So we'll say firstString equals differentString.

And you remember different string was the one that was created with the new.

So see differentString was created with the new string, Craig, and

the first string was a literal.

So they're two separate, they're in, they're in different memory pools.

Let's just make sure that worked.

YAY.

So how does that equals method work?

Well for strings,

it must check that every single character is the same in the other string.

So the way this works is that string has overridden the equals method

on this class definition.

Now I have added a link in the teacher's notes about how you might want to go about

writing your own equals method in your own classes.

All right, let's review the output of your exploration here together one more time.

So primitives use double equals.

Object references use double equals to check if they refer to the same object in

memory, seemingly equal objects are not equal.

Object references must refer to the same object to use double equals.

So that's the only time you should use double equals.

Now string literals are actually referring to the same object.

Remember they go into the string pool together.

String objects that contain the same characters but

point to different objects can not use double equals.

String interning adds to the same string pool where literals live.

So you can get back the same reference, if it exists of course.

And, all objects should use equals to check for equality, and

you can write your own.

So I hope this knowledge will arm you,

as you come up against confusing encounters with strings.

And help remind you that you are, in fact, not going crazy.

So there you go.

I hope that cleared things up for you and

if nothing else it should give you something to refer back to

if you do in fact end up thinking you're losing your mind about strings.

If you like this format and

would like to see more like this please speak up in the forum.

And we'll tackle some more of the more nuance problems that

all we developers encounter from time to time.

As always, your suggestions are very welcome and

really help to shape what we're building together here.

Thanks for hanging out, and see you soon.