Hello guys, welcome back to the next tutorial. So in the last one we discussed about the maps. And in this one I'm going to talk about the different kind of maps and how we can iterate over the maps. Since we have maps, we definitely need to know how we can iterate over those different entries and the keys and the values right, in order to retrieve stuff and perform actions from them. So what I've done is it's a new class map situation. And I wanted to define the map, which is the basic one that we talked about in the last class.

This is the hash map. This is the command that it does not maintain any honor, as you have seen in the hash set. And I've just entered all those three values that we define entries, I would say the values, three entries that we defined in the last tutorial. So let's see what others how we can iterate over these. So as we know that these are entries, the way we iterate over these is we're going to use the entry set, right? So map dot entry.

This is the this is the entry and it's going to have key value, right the key represents key and the way we represent value. So the key is of type integer right now, and the value is of type string. And there's a typo, right. So this is our key. And this is our value. And we're going to provide a name here.

So let's say this is our entry out of our complete entry set. So since one, one key value pair is an entry, and all of these, we can say this is a set of entries that we have. So to trade our one entry, we're just giving it a name. So this is a name dice, you can just say item as well, you can just say, values on anything. So what I'm doing right now is empty, it will be just more obvious. So entry, or our entry set, right?

So the name of our map is map here. So maybe let's just say, hash map, something like that. So it's more obvious what kind of map you're working on. So let's just copy these two here, and here and here. And here. We can just say, hash map dot entry set.

So this is our complete entry server, it's going to have all the entries. And we're going to iterate over these entries one by one. So this is our for loop. And here's how we iterate over the map. So what we can do right now is we can find the keys. So since the keys of type integer, we can just say and and just define a variable called key.

And from the map, or we can do is, we have the entry, we're iterating over the entries, right entry dot get key, it's just going to give me the key of that particular entry. And then I can define string value, and then mp3 dot get value, it's just gonna give me the value of that particular entry. And don't worry about using the end instead of integer. Java is gonna take care of the auto boxing so it doesn't even matter. It's just gonna take care of it. So right now what we're doing is we can just I can just print this thing out and show it to you.

So let's see. Say key. And I can use the key here, class. Let's format it properly value is our value, right? So I can just run the score and show it to you. So key one value BMW key four value Honda key six, value Adi.

And you guys can see this no particular order, right? It's right now looks like natural order one, four and six. But you cannot rely on that because it's a hashmap and does not maintain any order. So we enter in the order of BMW, Audi, Honda, but we are getting a different order which is, which is more looking like a natural order. But I cannot allow that because that's what the definition of the hashmap is. So that's what the hashmap looks like.

So let's take a look at the other and the other way of iterating or the maps. So the other ways what we can do is since we have the keys and the values, right, we have all these entries. So the way it maintains the entry set and reset the hashmap in maintains a key set as well. So what we can do is we can just simply iterate over the key set. So since our key is of type integer, we can just say this. And iterating over the key set lets you use the key.

And this is just the name again, one key for the key set. So we're going to iterate over each key, right? And hash map, right, this is the name of our map, dot key set. So similar way, we had an entry set, now we have a key set as well. And we can just go straight over this. So how we can relate the retrieve the value now we can just see the values of type string, so string, and maybe value.

And then we can just see our hash map dot get. And since we have all the keys, we had a Trojan what were the keys we can just use this key, right? This is how we get values right? So we can just use get Key, now we're going to have the value. And I can just see see. So right here, what I can just copy this, I can straight away copy this because it's going to be exactly the same.

So I can just have one more SQL statement here, too. Creation Tool, right? So we know that which iteration we are looking at. And this is equation number one. So let's run this code again. Situation one is this, and attrition to business.

So we pretty much can achieve the same thing using either of the ways of trading or the maps. And what I was talking about is this thing that you guys might see that I'm using the same variable names by the string values is string values here, but don't worry because they are inside the for loop. So they have the scope scope of the for loop, only. This one is not visible outside the follow. So I can again use it in a different block. So this is a completely one block only one block of code, so it's not visible outside.

So inside two different for loops, we can use the same name. But if I have a string value defined here, let's say this, I'm going to have no space because this value name is defined outside of follow, which is visible in the complete method. So I cannot define a value here, right? So this is pretty okay. So now let's talk about the different kinds of maps, right? So similar way we have maps, in the same way that we have the hash map.

So let's just copy this path from here. And let's just have it here. So instead of a hash map, what we can have is a linked hash map. This is one type. And let's call it link, right link map, something like that. Just to make it shot and imported imported from the Java dot util.

And exactly in the same manner. We can have a key map. And they're exactly like the way we talked about inset, right? So, exactly the same way that link hashmaps. They maintain the order in which they are added. Right.

And the tree map maintains natural sorting order. Natural sorting, right. So that's what the thing is. And what I can show you is maybe just quickly have the things here, copy this here. And instead of hashmap, let's put link map here, right. So let's put the link map here.

And let's quickly trade over this one. I just want to copy this. So let's quickly iterate over this one. And so the hash map, I just want to say the link map because that's the one I want to iterate over. And let's call it iteration number three. So in this one, what we expect is because it's a link map, the order should be maintained.

So the order should show as BMW, Audi, and Honda because that's what it says. It maintains the order in which they are added. So let's just run this code. And let's see the output. So for iteration one, and two, you guys can see this, right. But for the iteration three, you can see the key one, and then it appears the key six and then base the key four, so it is maintaining the order in which they were adding, and that's the benefit of being hashmap.

Now, comes the question that what's the difference between hash maps Ling hash maps and the tree maps. So that's what the difference is the order of integration. So hashmap makes no guarantee Which is kinda a trade, it can just be trade in any arbitrary order. But the three maps are always going to maintain the natural sorting and the length hashmaps are always going to maintain the order in which the entries were added. This is the difference. So another thing is that the hash maps, they allow one null key.

So we can add one null key in the hash map. Because the case cannot be duplicate. Obviously, there cannot be more than one key because otherwise it's gonna be duplicated. So other thing like when do we want to decide which one to use either a hash map or the tree map. So it is pretty simple. If you are just using it for a plain simple purpose always use hash map because that's faster.

It does not have any button on it. It does not have to maintain any order. It's just quick. But if you want that whichever order you are inserting values you want to retain that use link linked hash map. And if you want to maintain the order of natural sorting, which comes with The burden because then the tree map has to sort them in the natural sorry, then use the tree map, which comes with a little bit of performance hit and are not very stable, you're not going to see the performance in the small map. It's always seen when you have a large quantity of entries added.

So just make a wise decision in which whichever map you want to use, what's your use case? So for the simplest one, always go with the hash map. So yeah, they just try to see these guys. Try to see how you can iterate over the maps and use these different kind of maps. So that's pretty much it for this one, guys. Thanks for attending this one.

Stay tuned for the next one, guys. Thanks, guys.