Résumé de l'utilisation de base de la collection
Cinq, interface de carte
Permettez-moi de parler de quelques concepts de base:
La carte stocke les paires clé-valeur (clé-valeur), où: la clé est stockée avec Set! Donc, une fois que nous écrivons une classe nous-mêmes, si nous voulons que ce soit la clé, nous devons réécrire les méthodes hashcode () et equals ()! Ensuite, introduisez les classes détaillées qui implémentent l'interface Map:
5.1, collection HashMap
Permettez - moi de parler de la connaissance HashMap première:
① Similaire à HashSet, la clé et la valeur de NULL sont autorisées.
② Il est également la paire valeur clé indexée par la valeur de hachage, de sorte que l'efficacité d'accès est très élevé, et l'efficacité de la recherche est également très élevé (supérieur à la mise en œuvre d' arbre La complexité temporelle de la constante!)
③ Dans HashMap, la condition pour juger de deux clés est la même: d'abord juger si le hashcode () est le même, puis juger equals (), et la seule condition pour juger si la valeur est la même est juger égal () Est vrai!
5.1.1. Regardons d'abord un exemple:
package MapInterface;
import java.util.*;
/**
* @author jiangzl
*/
public class MyHashMap {
public static void main(String[] args){
HashMap myHashMap = new HashMap();
myHashMap.put("stu1", 1);
myHashMap.put("stu2", 2);
myHashMap.put("stu3", 3);
myHashMap.put("stu3", 4);
myHashMap.put("stu4", 5);
System.out.println("-----------第一种遍历HashMap的方法-----------");
Set keySet = myHashMap.keySet();
Iterator iterator = keySet.iterator();
while (iterator.hasNext()){
Object key = iterator.next();
Object val = myHashMap.get(key);
System.out.println("key = " + key + " , value = " + val);
}
System.out.println("-----------第二种遍历HashMap的方法-----------");
Set entrySet = myHashMap.entrySet();
iterator = entrySet.iterator();
while (iterator.hasNext()){
Map.Entry kv = (Map.Entry)iterator.next();
Object k = kv.getKey();
Object v = kv.getValue();
System.out.println("key = " + k + " , value = " + v);
}
}
}
Jetez un œil à la sortie de cet exemple:
5.1.5. Expliquez cet exemple:
Premièrement: à propos de l'accès à HashMap:
Le dépôt utilise la méthode put (key, value);, il y a plusieurs façons de l'obtenir: si vous connaissez la clé, vous pouvez utiliser la méthode get (key), et la valeur de value vous sera retournée. Mais parce que HashMap permet à la clé et à la valeur d'avoir des valeurs nulles! Il est donc préférable de porter un jugement vide avant d'utiliser la méthode get (key)!
Deuxièmement: à propos de la traversée de HashMap
Son parcours est vraiment différent des autres interfaces de collection! Parce qu'il n'a pas d'itérateurs qui peuvent être manipulés directement! Mais nous savons que si nous pouvons parcourir chaque clé, nous pouvons obtenir chaque paire clé-valeur! Ou pour obtenir chaque paire clé-valeur, vous pouvez également obtenir la clé et la valeur via les méthodes getkey () et getvalue ()!
Méthode 1: Traverser chaque clé: Nous pouvons utiliser: Set keySet = myHashMap.keySet();pour obtenir un objet Set ( rappelez-vous que ce n'est pas un objet HashSet ) et après avoir cet objet, vous pouvez utiliser des itérateurs pour le parcourir!
Exemple détaillé:
Set keySet = myHashMap.keySet();
Iterator iterator = keySet.iterator();
while (iterator.hasNext()){
Object key = iterator.next();
Object val = myHashMap.get(key);
System.out.println("key = " + key + " , value = " + val);
}
Méthode 2: Parcourez chaque paire clé-valeur, utilisez:, Set entrySet = myHashMap.entrySet();puis utilisez getX () pour obtenir la clé et la valeur!
Exemple détaillé:
Set entrySet = myHashMap.entrySet();
iterator = entrySet.iterator();
while (iterator.hasNext()){
Map.Entry kv = (Map.Entry)iterator.next();
Object k = kv.getKey();
Object v = kv.getValue();
System.out.println("key = " + k + " , value = " + v);
}
Deux considérations:
Premièrement: il y a une ligne de code à noter: même lors de l'obtention de paires clé-valeur, une méthode statique de Map: Entry () est requise!
Deuxièmement: si vous ne savez pas quel type de données sont la clé et la valeur spécifiques, il est préférable d'utiliser la classe Object, puis d'opérer en fonction du polymorphisme. Bien sûr, ce serait bien si vous pouvez connaître le type spécifique!
Troisièmement: j'ai oublié de le mentionner auparavant, HashMap ne permet pas de mapper une clé sur deux valeurs! Donc après deux opérations de mise sur une clé, seule la dernière mise en place sera conservée!
5.1.6. Résumé de plusieurs méthodes de Map couramment utilisées:
1. Ajouter une fonction:
V put (touche K, valeur V): ajouter un élément.
Si la clé est stockée pour la première fois, stockez l'élément directement et renvoyez null.
Si la clé n'existe pas pour la première fois, remplacez la valeur précédente par la valeur et renvoyez la valeur précédente.
2. Fonction de suppression:
void clear (): supprime tous les éléments de paire clé-valeur
V remove (clé d'objet): supprime les éléments de paire clé-valeur en fonction de la clé et renvoie la valeur
3. Fonction de jugement:
boolean containsKey (Object key): juge si l'ensemble contient la clé spécifiée
boolean containsValue (Object value): juge si l'ensemble contient la valeur spécifiée
boolean isEmpty (): juge si l'ensemble est vide
4. Get function:
Set <Map.Entry <K, V >> entrySet ():
V get (Object key): récupère la valeur en fonction de la clé
Set keySet (): récupère la collection de toutes les clés de la collection
Collection values (): récupère la collection L'ensemble de toutes les valeurs dans
5. Fonction Length:
int size (): renvoie le nombre de paires clé-valeur dans la collection
5.3, collection LinkedHashMap
En fait, c'est super simple, c'est-à-dire que la couche inférieure est implémentée par hachage et liste liée. Ce qui peut être fait est de maintenir la séquence itérative de Map pour s'assurer que ce que vous entrez est ce que vous sortez. Ensuite, la classe HashMap est héritée, donc l'efficacité est également très élevée. Le scénario d'application est également évident, c'est-à-dire que lorsque vous avez besoin que l'ordre d'entrée et l'ordre de sortie soient cohérents, utilisez cet ensemble, jetons un coup d'œil au code:
package MapInterface;
import java.util.*;
/**
* @author jiangzl
*/
public class MyHashMap {
public static void main(String[] args){
LinkedHashMap myHashMap = new LinkedHashMap();
myHashMap.put("stu1", 1);
myHashMap.put("stu2", 2);
myHashMap.put("stu3", 3);
myHashMap.put("stu3", 4);
myHashMap.put("stu4", 5);
Set keySet = myHashMap.keySet();
Iterator iterator = keySet.iterator();
while (iterator.hasNext()){
Object k = iterator.next();
Object v = myHashMap.get(k);
System.out.println("key = " + k + " , value = " + v);
}
}
}
Regardez la sortie:
C'est très simple, non? En fait, l'ordre de sortie est cohérent avec l'ordre d'entrée, puis l'efficacité est la même que HashMap.
5.2, collection TreeMap
Ce n'est pas différent de TreeSet, vous pouvez lire mon dernier article:
Collection d'ensemble détaillée
Voici une introduction détaillée à ce TreeSet, en fait, TreeMap n'a rien de spécial, jetons un œil au code source:
public TreeMap(Comparator<? super K> var1) {
this.comparator = var1;
}
On peut voir à partir de là que le TreeMap basé sur l'arbre de tri qui implémente un ordre personnalisé est le même, tout comme le TreeSet!
5.2.1. Regardez la seule différence entre TreeMap et TreeSet
Les objets triés par TreeSet sont les éléments de la collection TreeSet, et les objets triés dans l'arborescence sont les clés de chaque paire clé-valeur!
5.2.2. Regardez un exemple de tri naturel:
package MapInterface;
import java.util.*;
public class MyTreeMap {
public static void main(String[] args){
TreeMap myTreeMap = new TreeMap();
myTreeMap.put("stu4", 1);
myTreeMap.put("stu5", 2);
myTreeMap.put("stu3", 3);
myTreeMap.put("stu2", 4);
myTreeMap.put("stu1", 5);
Iterator iterator = myTreeMap.entrySet().iterator();
while (iterator.hasNext()){
Map.Entry entry = (Map.Entry)iterator.next();
Object k = entry.getKey();
Object v = entry.getValue();
System.out.println("key = " + k + " , value = " + v);
}
}
}
Alors jetez un œil à la sortie de cet exemple:
il est clair que ce que nous voyons est une collection de TreeMap triée par clé (ordre du dictionnaire)
5.2.3. Regardez un exemple de tri personnalisé:
package MapInterface;
import java.util.*;
public class MyTreeMap {
public static void main(String[] args){
TreeMap myTreeMap = new TreeMap(new MyComparetor());
myTreeMap.put("stu4", 1);
myTreeMap.put("stu5", 2);
myTreeMap.put("stu3", 3);
myTreeMap.put("stu2", 4);
myTreeMap.put("stu1", 5);
Iterator iterator = myTreeMap.entrySet().iterator();
while (iterator.hasNext()){
Map.Entry entry = (Map.Entry)iterator.next();
Object k = entry.getKey();
Object v = entry.getValue();
System.out.println("key = " + k + " , value = " + v);
}
}
}
class MyComparetor implements Comparator{
@Override
public int compare(Object o1, Object o2) {
String s1 = (String)o1;
String s2 = (String)o2;
return s2.compareTo(s1);
}
}
Jetez un autre coup d'œil à cet exemple de tri personnalisé, le résultat de sortie est:
C'est très simple, donc je ne vais pas répéter les raisons.Pour plus de détails, veuillez vous référer à mon dernier article, il y a un lien en face!