Hello, guys, welcome back to the next tutorial. And this one, we are kind of talking about our collections framework and to our next class discussing about collection framework. So today we will talk about linked list. So we'll continue our discussion from the ArrayList. Let me just quickly bring up the eclipse. And let me just show you.

So last time, we discussed this ArrayList, right. And today, we have our linked list. So I just have an empty class. And there's nothing into it. I'm just going to show you very quickly that pretty much a lot of things are same and common in these things. And we'll talk about the differences and all those things.

So let's see. So let me just do one thing. If you guys see this is an empty class linkless demo, and from a list demo, what I'm going to do is I'm going to copy everything, and I'm going to copy everything till here. And I'm just going to simply paste it and next thing I'm gonna do is I'm just gonna remove this to link list. And same thing I'm going to do to this thing, right. So if you guys notice, what I just did is I just replaced ArrayList with linked lists, and everything stays the same.

If you guys notice this add method, same size method is same, then retrieving good method is same. And pretty much removed method is same, everything is same, like it works like a charm. If I just run it, you guys can see it, all the things work exactly like the ArrayList. So they are pretty much exactly the same thing. And there are different so I'm going to talk about those, but they're almost like same, so you guys can use them interchangeably. And if your list is small, definitely you don't even have to worry less if your list is considerably smaller, like hundred or 500 items or something like that, or maybe even thousand items.

You don't even have to worry it just pretty much the exact same thing. So you know, what are the differences that so let's talk about Got it. Let me just actually kind of start from here and as follows. So, usually, maybe, just let me comment out something like, okay, so ArrayList usually there's a base right that I talked about. So how would they look they would look something like this. And let's see if I have integers like 012345 and six something like this right?

They will look something like this there anyways. But linkless is actually kind of it can contains elements where each element has a reference to its previous element and to its next element. So, you can you can see some, imagine something like this. So let's say zero, and then it has a reference to next element then one and then it has a reference to next element, then to And then actually, if you guys because if you have to do this, we have to refer the back as well. So one has the reference to zero and then two has the reference to one. So basically they point to each other and that's how linkless works.

So where is the difference? difference comes in, always use a realist when Okay, let me just write it write it explicitly. So realist when you have to add at the end and remove from the end, right? And getting is fast. Okay linkless when you have to add at the beginning Remove from the beginning. All right, so why why so as I talked in the last tutorial as well, right?

When we are talking with ArrayList, if you remove something from the beginning, like let's say you remove one, it has to relocate everything. And it has to just bring this to a pair three pair. Otherwise there's there's got to be an empty index. And that's not what we want. So this can be like a memory leak and all those sorts of issues in Java. So Java handles it by moving all these elements, shifting them by one.

So the array relocates itself and Java does it. We don't have to do it. But yes, internally, it causes some, some memory and some CPU uses to Java, right. So that's why it takes more amount of time. While in linkless, because it's just a reference, it's a pointer sort of thing both ways. So if we remove something like this, it just changes the pointer to two and this pointer to zero and then it just works like anything.

So it's fast. That's the difference. So What I'm gonna do is I'm going to show you real quick examples. And maybe one more thing. So since they both implement the list interface, so what we can do is guys, instead of kind of declaring things like this, we can declare simply like this. So I'm just gonna change this to list.

And maybe here some, maybe, let's say link list. Right? So it implements the list interface, right. So anything that implements the list interface can be just declared like this starting from list and type we need to give, and we can just name the exact type that we want to implement. So linkless is the class that we are implementing that we're using. So here, let me just change it to integers because I'm just going to create them create a method, so integer, and not integers integer.

And let's declare one more. So in teacher and ArrayList, and then New ArrayList and then integer, right. So that's how we can create both of them. So if you guys see, we just created an ArrayList and linked lists with the same way, right? We use the same interface and it's all done. Right?

So sounds good, pretty, pretty nice and decent. So you know what, that's all I wanted to talk about in this tutorial, I just wanted to show you that we can actually implement these things using the same list and replace and this is just a list now we can add anything to it like a list dot add or something anything we can use, and it has like few methods also like so add has a method for adding teacher right, we can add at an index. And then other than this, I wanted to show you one more method. So if I say add, it has this method as well. So this is like specifying the index where you want to add so I can specifically add it Maybe second index. And I can add the element, whichever element that I want to, or maybe 10, because it sets an integer, right.

So I can specifically add stuff to different indexes in this as well. So that's also one of the Add methods. So that certain done guys, that's pretty much it I wanted to show in this tutorial. In the next one, I'm actually going to be comparing the performance of these in different conditions and talking about the differences in these things, more differences. So these are the differences that we already saw. But we'll talk about the differences in action actually will actually do those things.

So he asked him for the next lectures, guys, thanks for attending this one. Thank you.