Qu'est-ce qu'une collection de cartes ? Caractéristiques des collections de cartes

Caractéristiques de la collection Map :
1. Il s'agit d'une collection à double colonne. Lors de l'attribution de valeurs, la clé et la valeur doivent être attribuées en même temps.
2. (stockage et suppression d'éléments). L'ordre peut être incohérent)
3. La valeur de la clé ne peut pas être répétée, mais la valeur peut être répétée
4. Une clé ne peut correspondre qu'à une seule valeur
5. En définissant une collection, la clé et la valeur du type de données peuvent utiliser le même type de données. Vous pouvez également utiliser différents types de données

Caractéristiques de la collection Map
java.util. MapInterface : Collection, qui est une collection à deux colonnes

La première façon de parcourir une collection de cartes
La première façon de parcourir une carte collection : trouver une valeur par clé
Il existe une méthode dans la collection Map : keySet
Set Renvoie une vue Set des clés contenues dans cette carte. Stockez les clés de la collection Map dans une collection Set
Étapes pour parcourir la collection Map :
1. Définir une collection Map et ajouter des éléments à la collection
2. Appeler la carte collection La méthode dans keySet stocke les clés de la collection Map dans une collection Set
3. Parcourez la collection Set et obtenez toutes les clés de la collection Map
4. Utilisez la méthode get de la collection Map pour effectuer une recherche les clés obtenues. Valeur

 1 public static void main(String[] args) { 2         //1.定义一个Map集合,往集合中添加元素 3         Map<String,String> map = new HashMap<String,String>(); 4         map.put("a", "1"); 5         map.put("b", "2"); 6         map.put("c", "3"); 7         map.put("d", "4"); 8         //2.调用Map集合中的方法keySet,把Map集合中的健存储到一个Set集合中 9         Set<String> set = map.keySet();10         //System.out.println(set.getClass());11         //3.遍历Set集合,获取Map集合所有的健12         //使用迭代器遍历13         Iterator<String> it = set.iterator();14         while(it.hasNext()){15             String key = it.next();16             //4.通过获取到的健,使用Map集合的方法get查找值17             String value = map.get(key);18             System.out.println(key+"..."+value);19         }20         System.out.println("----------------");21         //使用增强for遍历22         for(String key : set){23             //4.通过获取到的健,使用Map集合的方法get查找值24             String value = map.get(key);25             System.out.println(key+"..."+value);26         }27         System.out.println("----------------");28         //使用增强for遍历29         for(String key : map.keySet()){30             //4.通过获取到的健,使用Map集合的方法get查找值31             String value = map.get(key);32             System.out.println(key+"..."+value);33         }34     }

La deuxième façon de parcourir la collection de cartes
La deuxième façon de parcourir la collection de cartes : la manière de parcourir les clés- paires de valeurs
Il existe une méthode dans la collection Map : EntrySet
Set> EntrySet() renvoie la vue Set de la relation de mappage contenue dans cette carte.
Étapes de parcours :
1. Définir une collection Map et ajouter des éléments à la collection
2. Appeler la méthode EntrySet dans la collection Map pour ajouter chaque relation de mappage dans la collection Map ( Certificat de mariage) dans la collection Set
3. Parcourez la collection Set et obtenez chaque relation de mappage Entry
4. Utilisez les méthodes getKey et getValue dans Entry Valeur

 1 public static void main(String[] args) { 2         //1.定义一个Map集合,往集合中添加元素 3         Map<String,String> map = new HashMap<String,String>(); 4         map.put("a", "1"); 5         map.put("b", "2"); 6         map.put("c", "3"); 7         map.put("d", "4"); 8         /* 9          * 2.调用Map集合中的方法entrySet,把Map集合中的每一个映射关系(结婚证)放入到Set集合中10          * 成员内部类的访问方式:外部类.内部类(Map.Entry)11          */12         Set<Map.Entry<String, String>> set = map.entrySet();13         //3.遍历Set集合,获取每一个映射关系Entry<K,V>14         //使用迭代器遍历Set集合15         Iterator<Map.Entry<String, String>> it = set.iterator();16         while(it.hasNext()){17             Map.Entry<String, String> entry = it.next();18             //4.使用Entry<K,V>中的方法getKey和getValue获取健和值19             String key = entry.getKey();20             String value = entry.getValue();21             System.out.println(key+"..."+value);22         }23         System.out.println("---------------------");24         //使用增强for遍历Set集合25         for(Map.Entry<String, String> entry:set){26             //4.使用Entry<K,V>中的方法getKey和getValue获取健和值27             String key = entry.getKey();28             String value = entry.getValue();29             System.out.println(key+"..."+value);30         }31         System.out.println("---------------------");32         //使用增强for遍历Set集合33         for(Map.Entry<String, String> entry:map.entrySet()){34             //4.使用Entry<K,V>中的方法getKey和getValue获取健和值35             String key = entry.getKey();36             String value = entry.getValue();37             System.out.println(key+"..."+value);38         }39     }

HashMap stocke la valeur de clé de type personnalisé
HashMap stocke la valeur de clé de type personnalisé
Type personnalisé comme valeur de la collection Map
Type personnalisé comme clé de la collection Map

Rappelez-vous : lorsque les types personnalisés remplacent hashCode et égal à
1. Utilisez HashSet pour stocker les types personnalisés
2. Utilisez les collections HashMap et utilisez des types personnalisés pour les clés

🎜>

Hashtable
Classe d'implémentation de carte Hashtable
La structure de données sous-jacente est une table de hachage, les caractéristiques sont les mêmes que hashMap
Hashtable est une collection thread-safe et s'exécute lentement
HashMap est une collection non sécurisée pour les threads et s'exécute rapidement

Hashtable a le même sort que Vector À partir du JDK1.2, il a été remplacé par le HashMap plus avancé

HashMap permet de stocker. valeur null, clé nulle
Hashtable ne permet pas de stocker la valeur nulle, clé nulle

Hashtable Ses enfants, sous-classes Les propriétés sont toujours actives en phase de développement

Fonctionnalités de la collection LinkedHashMap
java.util.LinkedHashMap étend HashMap implémente Map
Caractéristiques de la collection LinkedHashMap :
1. Table de hachage + liste chaînée : liste doublement chaînée, qui peut garantir l'ordre d'itération
2. Clé ne peut pas être répété

Collections
java.util.Collections : classe d'outils pour faire fonctionner Collection
Les méthodes de la classe d'outils sont toutes des méthodes statiques et peuvent être utilisées directement via le nom de la classe

public static void sort(List list) // Trier les éléments de la collection
public static void shuffle(List list) // Shuffle l'emplacement de stockage des éléments de collection

Paramètres variables
Nouvelles fonctionnalités apparues après JDK1.5
Prérequis d'utilisation : Le type de données des paramètres de la méthode est déterminé, mais le nombre de paramètres est incertain

Utilisation du format  :
Nom de la méthode du type de valeur de retour du modificateur (type de données... nom de la variable) {
}
... représente que la méthode peut recevoir plusieurs paramètres du même type de données
La couche inférieure du paramètre variable peut être traitée comme un tableau

Notes sur les paramètres variables :
1. Pour les paramètres d'une méthode , un seul paramètre variable peut être utilisé
2. Si les paramètres de la méthode Il y en a plusieurs, les paramètres variables doivent être écrits à la fin de la liste des paramètres

 1 public static int add(int...arr){ 2         System.out.println(arr);//[I@104c575 3         System.out.println(arr.length); 4         int sum = 0; 5         //遍历可变参数-->遍历数组 6         for (int i : arr) { 7             sum +=i; 8         } 9         10         return sum;11     }

Importation statique
Nouvelle fonctionnalité JDK1.5, importation statique
Réduire la quantité de code développé
Méthode d'écriture standard, ne peut être utilisée que lors de l'importation d'un package
importer du java statique. lang.System.out; À la fin, il doit s'agir d'un membre statique

package cn.itcast;

import java.util.ArrayList;
import java.util. Collections;
importer java.util.HashMap;

  1 /*  2  * 带排序功能的斗地主案例:  3  *     1.准备牌  4  *     2.洗牌  5  *     3.发牌  6  *     4.排序  7  *     5.看牌  8  */  9 public class DouDiZhu { 10     public static void main(String[] args) { 11         //1.准备牌 12         //创建存储序号和拍面值的Map集合 13         HashMap<Integer,String> poker = new HashMap<Integer, String>(); 14         //创建存储序号的List集合 15         ArrayList<Integer> pokerNumber = new ArrayList<Integer>(); 16         //创建序号的数组 17         String[] numbers = {"2","A","K","Q","J","10","9","8","7","6","5","4","3"}; 18         //创建花色数组 19         String[] colors = {"?","?","?","?"}; 20         //先把大王和小王存储到集合中 21         int index = 0; 22         poker.put(index, "大王"); 23         pokerNumber.add(index); 24         index++; 25         poker.put(index, "小王"); 26         pokerNumber.add(index); 27         index++; 28          29         //使用循环嵌套遍历两个数组,组成52张牌 30         for (String number : numbers) { 31             for (String color : colors) { 32                 //把组合包的牌添加到集合中 33                 poker.put(index, color+number); 34                 pokerNumber.add(index); 35                 index++; 36             } 37         } 38         //System.out.println(poker); 39         //System.out.println(pokerNumber); 40          41         //2.洗牌:洗的是牌的序号 42         //使用Collections中的方法shuffle 43         Collections.shuffle(pokerNumber); 44         //System.out.println(pokerNumber); 45          46         /* 47          * 3.发牌:发的也是牌的序号 48          *     a.定义4个集合存储3个玩家和1个底牌 49          *     b.遍历存储序号的List集合 50          *     c.使用list集合的索引%进行判断进行发牌 51          *     注意:先判断底牌 52          */ 53         //a.定义4个集合存储3个玩家和1个底牌 54         ArrayList<Integer> player01 = new ArrayList<Integer>(); 55         ArrayList<Integer> player02 = new ArrayList<Integer>(); 56         ArrayList<Integer> player03 = new ArrayList<Integer>(); 57         ArrayList<Integer> diPai = new ArrayList<Integer>(); 58          59         //b.遍历存储序号的List集合 60         for(int i=0; i<pokerNumber.size(); i++){ 61             //定义变量,接收排的序号 62             int number = pokerNumber.get(i); 63             //c.使用list集合的索引%进行判断进行发牌 64             if(i>=51){ 65                 //存储底牌 66                 diPai.add(number); 67             }else if(i%3==0){ 68                 //给玩家1发牌 69                 player01.add(number); 70             }else if(i%3==1){ 71                 //给玩家2发牌 72                 player02.add(number); 73             }else if(i%3==2){ 74                 //给玩家3发牌 75                 player03.add(number); 76             } 77         } 78         /*System.out.println(player01); 79         System.out.println(player02); 80         System.out.println(player03); 81         System.out.println(diPai);*/ 82          83         //4.排序 84         //使用Collections中的方法sort 85         Collections.sort(player01); 86         Collections.sort(player02); 87         Collections.sort(player03); 88         Collections.sort(diPai); 89          90         /*System.out.println(player01); 91         System.out.println(player02); 92         System.out.println(player03); 93         System.out.println(diPai);*/ 94          95         /* 96          * 5.看牌 97          */ 98         //调用看牌方法 99         lookPoker("刘德华",player01, poker);100         lookPoker("周润发",player02, poker);101         lookPoker("周星驰",player03, poker);102         lookPoker("底牌",diPai, poker);103     }104     105     /*106      * 定义一个看牌的方法107      * 返回值类型:void108      * 方法名:lookPoker109      * 参数列表:玩家和底牌的集合,存储排的Map集合110      * 使用查表法看牌:111      *     遍历List集合,获取Map集合key,使用key去Map集合中查找value112      */113     public static void lookPoker(String name,ArrayList<Integer> list,HashMap<Integer,String> map){114         System.out.print(name+":");115         //遍历List集合,获取Map集合key116         for (Integer key : list) {117             //使用key去Map集合中查找value118             String value = map.get(key);119             System.out.print(value+" ");120         }121         System.out.println();//换行122     }123 }

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!