Ensemble de cartes

Table des matières

Un.、Caractéristiques

2.、Expansion de la capacité

Trois、Traversée

Quatre、Réalisation

HashMap

HashTable

ConcurrentHashMap

TreeMap

LinkedHashMap

---

Un.、Caractéristiques

Désorganisation,Paire de clés,La clé ne peut pas être dupliquée,Les valeurs peuvent être répétées,Les touches dupliquées sont écrasées,Pas d'héritageCollectionInterface

2.、Expansion de la capacité

Expansion de la capacité：Capacité initiale16,Facteur de charge0.75,Augmentation de la capacité1X

Trois、Traversée

Préparation des données

private Map<String, Object>map=new HashMap<String, Object>();

	@Before
    public void setup() {
    	map.put("1", "Souris");
    	map.put("1", "Ordinateur");
    	map.put("2", "Ventilateur");
    	map.put("3", "Cartable");
    	map.put("4", "Discours");
    	map.putIfAbsent("1", "aaa");// Ajouter s'il manque 
    }

* Obtenez d'abord toutes les clés SetEnsemble,Encore une fois（Obtenir la valeur par clé）

@Test
	public void test01() {
		Iterator<String>it=map.keySet().iterator();
		while(it.hasNext()) {
			String key = it.next();
			System.out.println(map.get(key));
		}
	}

L'image de l'effet est la suivante:： 

  

* Sortez et sauvegardez tout EntryDeSet, Encore une fois SetC'est tout.

@Test
	public void test02() {
		Iterator<Entry<String, Object>> it = map.entrySet().iterator();
	    while(it.hasNext()) {
	    	Entry e=it.next();
	    	System.out.println("key = "+ e.getKey() +"  value ="+ e.getValue());
	    }
	}

L'image de l'effet est la suivante:： 

 

Quatre、Réalisation

• HashMap

HashMapThread not Secure for, Mais le plus souvent ,Vite!. Les tableaux sont utilisés à l'interne pour stocker les données .

Commençons par comprendre Processus d'exécution

Quand on vamapÀ l'intérieurput Quand l'élément, Vérifiez d'abord si ce tableau existe . Si ce n'est pas le cas , Une longueur par défaut de 16Tableau de. Les éléments ne sont pas stockés directement dans le tableau , C'est une série d'opérations. , En donnant keyObtenirkeyPosition dans le tableau, Ce tableau s'appelle le seau （ En calculant le nombre de noeuds dans le baril ）. L'élément pointé par le baril dans l'image est NodeNoeud（NodeEn fait,Entry<k,v>）. Calculé chaque fois qu'un élément est ajouté ,S'il n'y a pas d'élément, Un noeud est déclaré dans , Si les éléments stockés sont les mêmes, ils seront écrasés ,Au contraire, Il est ajouté en descendant par une liste liée （ Les éléments ajoutés sont en haut , Les éléments originaux descendent ）. 

  Comment obtenir la valeur ？ D'abord calculé ,Adoptionkey Trouver le seau où se trouve l'élément , Si c'est une liste liée , Trouver l'élément en traversant la liste .

Avec beaucoup d'éléments , La méthode ci - dessus nécessite une traversée complète pour trouver ,Il y a des défauts. Recherche à l'aide d'un arbre binaire  , Traversée par les conditions de l'élément , Cette liste n'a pas besoin d'être traversée .

  Revenez après avoir compris la structure Justification

Tout d'abord,MapÀ l'intérieurputValeur, Si trouvé vide , Créer un nouvel espace ,Sur la basekeyDehush Indice correspondant dans le tableau de calcul de la valeur . S'il n'y a pas de valeur dans le tableau, un nouveau noeud est généré , Jugez les noeuds de construction s'il y a lieu ,Si plus de8, Convertir en arbre Rouge et noir pour enregistrer les informations du noeud ,Pas plus de8 Enregistrer l'information dans la liste liée .

 Attention!： La partie verte de l'organigramme est JDK8 Nouvelle logique de traitement ,Le but est deTable[i]DansNodeNombre de noeuds supérieur à8Heure, Augmenter la vitesse de recherche grâce à l'arbre Rouge et noir .

• HashTable

HashTable Thread Safe but not used

public void test03() {
		Map<Integer, Object>table=new Hashtable<Integer, Object>();
		table.put(1, "Zhang San");
		table.put(2, "Li - si.");
		table.put(3, "Wang Wu");
		table.put(4, "Lao Liu");
		Iterator<Integer> it = table.keySet().iterator();
	    while(it.hasNext()) {
	    	int key=it.next();
	    	System.out.println(table.get(key));
	    }
	}

• ConcurrentHashMap

Sécurité des fils,QueHashTableHaute performance

public void test04() {
		Map<Integer, Object>cmap=new ConcurrentHashMap<Integer, Object>();
		cmap.put(1, "Zhang San");
		cmap.put(2, "Li - si.");
		cmap.put(3, "Wang Wu");
		cmap.put(4, "Lao Liu");
		Iterator<Integer> it = cmap.keySet().iterator();
	    while(it.hasNext()) {
	    	int key=it.next();
	    	System.out.println(cmap.get(key));
	    }
	}

• TreeMap

key Les valeurs sont triées dans un certain ordre , Performances plus élevées lors de l'ajout ou de l'obtention d'éléments HashMapDoucement, C'est parce qu'il faut entretenir les arbres rouges et noirs à l'intérieur ,Pour garantirkeyOrdre des valeurs.

public void test05() {
		Map<Integer, Object>tmap=new TreeMap<Integer, Object>();
		tmap.put(1, "Zhang San");
		tmap.put(2, "Li - si.");
		tmap.put(3, "Wang Wu");
		tmap.put(4, "Lao Liu");
		Iterator<Integer> it = tmap.keySet().iterator();
	    while(it.hasNext()) {
	    	int key=it.next();
	    	System.out.println(tmap.get(key));
	    }
	}

 key La valeur par défaut est ascendante , Si vous voulez trier par ordre décroissant, vous pouvez utiliser un comparateur （AveckeyComparer）

public void test05() {
		Map<Integer, Object>tmap=new TreeMap<Integer, Object>(new Comparator<Integer>() {

			@Override
			public int compare(Integer o1, Integer o2) {
				
				return o2-o1;
			}
		});
		tmap.put(1, "Zhang San");
		tmap.put(2, "Li - si.");
		tmap.put(3, "Wang Wu");
		tmap.put(4, "Lao Liu");
		Iterator<Integer> it = tmap.keySet().iterator();
	    while(it.hasNext()) {
	    	int key=it.next();
	    	System.out.println(tmap.get(key));
	    }
	}

L'image de l'effet est la suivante:：

• LinkedHashMap

SuccessionHashMap,LinkedHashMapC'est ordonné., Et par défaut à l'ordre d'insertion , Quand nous voulons stocker séquentiellement key-valueHeure,Il faut l'utiliser.LinkedHashMapC'est

public void test06() {
		Map<String, String> linkedHashMap = new LinkedHashMap<>();
        linkedHashMap.put("name1", "josan1");
        linkedHashMap.put("name2", "josan2");
        linkedHashMap.put("name3", "josan3");
        Set<Entry<String, String>> set = linkedHashMap.entrySet();
        Iterator<Entry<String, String>> iterator = set.iterator();
        while(iterator.hasNext()) {
            Entry entry = iterator.next();
            String key = (String) entry.getKey();
            String value = (String) entry.getValue();
            System.out.println("key:" + key + ",value:" + value);
        }
	}

Les effets sont les suivants：