Hello, guys, welcome back to the next video. So in the last classes we have covered about ArrayList, and the linked list. And we're going to just continue talking about the differences between the earliest and the linked list. And this family is going to show you the practical example of that. So and it's a very important interview question as well. So let's quickly bring up our Eclipse.

And let's see what we talked about. So this is our implementation in the last tutorial of the linked list. And I just moved it on the top. And this is what we left off. So let's pick it up here. So what I want to talk about is, what's the differences I was talking about?

These things, right, that when you have to add at the end, and the Remove from removed from the end accolades, and so and getting as far as then you say, release, and when you have to add at the beginning and remove from the beginning, then you still increase, right. So that's what we were talking about. So let's see. Let's see what's the differences. So let's minimize this right now. It's just taking so much space, and I'm just gonna create a method public static and maybe Yeah, Why'd we have to make invite because we don't want to return anything and curation.

So I'm just naming it run duration, because I want to calculate the duration of these things when we add and remove stuff. And it's going to accept a list. Type in teacher, and let's name it list. And then string is the list type that I'm providing. So I'm going to pass what type of list that I'm adding. So we know what we are doing, basically.

So inside it, what I'm going to do is just first let me just print a few steps to make it look good. And it's easy to understand the code. So what I'm printing right now is making the duration method basically, so we know what we are doing, and for maybe just adding this type so we know that for weightless type, our method is starting. So we have two types, right ArrayList and the link lists and then Let's put something like capturing the time. So you want to capture the time. So let's declare it along and start time equals to system dot current milliseconds.

So this thing captures the system time in milliseconds. And then let's have as a long end time, so let's name it end time. And then let's have a duration, right? So long duration, which is in time, minus time, right? And then let's print out one more statement to actually print but this thing is, so duration of the list and type, whichever type we are printing right now. So let's type and then S. And we're going to print the duration, so plus duration, and then plus milliseconds, right?

So we have kind of crazy The prototype need code, and let's see what we are trying to do next. So what I'm gonna do is I'm going to add a lot of items to the list. So for n equals two, n i equals to zero. And from zero, I'm going to start and i less than equals to maybe hundred thousand, so once 10 hundred thousand, 10,000 hundred thousand, and then i plus plus, right? That's going to be a helicopter song you might be hearing sorry about that are in my control. So we got to Add list, right?

So list dot add. And we already saw that these add methods, they work on both ArrayList and the linked list because they both implement the interface called lists. And that's what we are doing right, less than a face. So they both work in the same manner. So you know what, what we're gonna do is in our main method, we're just going to call these two methods right away. So after this line, let's call these so run ration, right?

And let's type costs Let's call the earliest and then the type is released, right? And then let's call run duration, this time linked list and the type is linked list. So what I'm doing here is I'm calling this method twice. First, I'm passing the ArrayList. Then I'm passing the linked list and putting the type so we know which one we're writing for. Let's quickly run the code, right?

So I'm going to hit the run. So it shows me for the ArrayList. Adding it took seven milliseconds for the link list, it took four milliseconds, it's not a big difference. It's still pretty much the same. If I have like more elements, it might show a little bit of different but still pretty much the same, right? So we're almost pretty much the same, not lot of big issues in performance and all those things right.

So let's move this code out of the start time right out of the time capture thing, let's move on to code. Let's again minimize this, it's taking up a lot of space. So what I'm going to do next is I'm going to actually, first let me just calculate, since we already created a list, we added some elements. So let's find out the size, right? So in size equals to list dot size. And then let's say I want to add more elements.

So maybe elements to add equals to size plus maybe more hundred and 100,000. More, one stands hundred thousand, 10,000 hundred thousand, right? So it's 10,100 100,000. So right now, so what I'm doing is I'm adding more elements to the list, right? So that's what I'm going to do. So let's create one more for loop.

And for in i equals to the same we're gonna start from size. So last time, we already added from the zeroeth index. So the list is on Ready full. Now I want to add from the size. So this is the last right? So when the list is already full I, that's where I want to start.

So I want to add more elements from here. And then I should be less than element start at, right? That's what we want. And I and then plus plus, right? So here we adding more elements to the list. So let's, let's do this thing.

So list dot add, and then I right. And now, what we're doing is we have a list, we have some items, and now we're adding more items to the list at the end, right? So let's do that. Let's run the program. And let's see, if you guys can see it's very easily. Again, adding to the ArrayList took only three milliseconds and to the list.

It took seven milliseconds, right. So it takes takes less time when we are adding to at the end right? Using the ArrayList. You guys can again see that it took three milliseconds it took seven milliseconds here. So if not the as much of a difference, you know what? Let's actually increase this.

Let's make it 200,000. And on that, so you guys can still see a list of priests again, three milliseconds and linkless took five milliseconds, right? So this is what I was talking about. But I showed you one more method, right? To add elements in the last class, that method is list dot add, and to a particular index. So let's say every time I want to add in the beginning of the list, so I'm gonna put the index zero, and then element is I, right?

So when I do this thing, let's see the time difference. Let's run the code. So it's still running. All righty. That's the difference I was talking about. Right?

You guys can easily notice it. So duration for the ArrayList is 2754 milliseconds. But for the linked list, it's still five milliseconds, it's pretty much the same, right? We added at the end, it took about five to seven milliseconds, and even adding in the beginning to the same time. So that's what I was talking about today. I was mentioning that when you have to add in the beginning, then just use the linkless.

Don't use ArrayList. In that case, that's what I was talking about. So let's, let's actually comment this code out, right? So I'll show you the Remove example as well. So let's say I have all these elements added up all those things I know right? So let's start removed.

And if I remove from maybe 90,000, or something, maybe, maybe let's say let's say let's create a for loop and let's remove some items, right. So for end, i equals to maybe start from 90,000 90,000 and go till 92,000 and then i plus plus something like that, and then list dot remove, right and I so if I remove Because from the end of the list, right? Not exactly. And but it's close to end, right, and let's run this code and see if we can see if I'm removing towards the end ArrayList took only two milliseconds, but language took 40 milliseconds, right? That's a huge difference. That's what I want to show about when we are removing from towards the end of the list.

A list is taking a lot less time, right? But let's quickly copy this and then comment this one. Like that. I want to come in come complete blog on Friday, and then again, habit. So this time, I want to start from the beginning, if I'm removing from the beginning, and let's say first hundred elements are removed, right, so let's run the code again. And this time, see, it's not a big difference, because it's only hundred elements.

And we only have 1000 elements. So ArrayList took two milliseconds, but linkless took zero milliseconds, which means linkless is faster. When We're starting from the beginning of the list, right? And it does not take a lot of time. So that's what I wanted to show you guys, what I was talking about these things are keys. So keep these things in mind when you are actually having lists in your code.

So these things are really important to know that what you want to use if you want to use the ArrayList or the linked list. So that's pretty much it, guys. And stay tuned for the next lectures. Thanks for attending this one. Thanks, guys.