Was ist eine Kartensammlung? Eigenschaften von Kartensammlungen

Eigenschaften der Kartensammlung:
Es handelt sich um eine zweispaltige Sammlung. Bei der Zuweisung von Werten müssen gleichzeitig Schlüssel und Wert zugewiesen werden.
Es handelt sich um eine ungeordnete Sammlung (Speichern und Entfernen von Elementen)
3. Der Schlüsselwert kann nicht wiederholt werden
Ein Schlüssel kann nur einem Wert entsprechen
Wann Beim Definieren einer Sammlung können der Datentypschlüssel und der Datentyp denselben Datentyp verwenden

Merkmale der Kartensammlung
java.util. MapSchnittstelle: Sammlung, bei der es sich um eine zweispaltige Sammlung handelt

Der erste Weg, eine Kartensammlung zu durchqueren
Der erste Weg, eine Karte zu durchqueren Sammlung: Finden Sie einen Wert anhand des Schlüssels
Es gibt eine Methode in der Map-Sammlung: keySet
Set Gibt eine Set-Ansicht der in dieser Map enthaltenen Schlüssel zurück. Speichern Sie die Schlüssel in der Kartensammlung in einer Set-Sammlung
Schritte zum Durchlaufen der Kartensammlung:
1. Definieren Sie eine Kartensammlung und fügen Sie Elemente zur Sammlung hinzu
2. Rufen Sie die Karte auf Sammlung Die Methode in keySet speichert die Schlüssel in der Map-Sammlung in einer Set-Sammlung
3. Durchlaufen Sie die Set-Sammlung und erhalten Sie alle Schlüssel in der Map-Sammlung
4. Verwenden Sie zum Durchsuchen die get-Methode der Map-Sammlung die erhaltenen Schlüssel. Wert

 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     }

Die zweite Art der Kartensammlungsdurchquerung
Die zweite Art der Kartensammlungsdurchquerung: die Art der Schlüsseldurchquerung Wertepaare
Es gibt eine Methode in der Map-Sammlung: enterSet
Set> gibt die Set-Ansicht der in dieser Map enthaltenen Mapping-Beziehung zurück.
Durchlaufschritte:
1. Definieren Sie eine Kartensammlung und fügen Sie Elemente zur Sammlung hinzu
2. Rufen Sie die Methode „entrySet“ in der Kartensammlung auf, um jede Zuordnungsbeziehung in der Kartensammlung hinzuzufügen ( Heiratsurkunde) in die Set-Sammlung
3. Durchlaufen Sie die Set-Sammlung und erhalten Sie jede Zuordnungsbeziehung Entry
4. Verwenden Sie die Methoden getKey und getValue in Entry, um die Schlüsselsumme zu erhalten Wert

 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 speichert benutzerdefinierten Typschlüsselwert
HashMap speichert benutzerdefinierten Typschlüsselwert
Benutzerdefinierter Typ als Wert der Kartensammlung
Benutzerdefinierter Typ als Schlüssel der Map-Sammlung

Denken Sie daran: Wenn benutzerdefinierte Typen hashCode und equal überschreiben
1. Verwenden Sie HashSet, um benutzerdefinierte Typen zu speichern
2. Verwenden Sie HashMap-Sammlungen und verwenden Sie benutzerdefinierte Typen für Schlüssel

Hashtable
Map-Implementierungsklasse Hashtable
Die zugrunde liegende Datenstruktur ist eine Hash-Tabelle, die Eigenschaften sind die gleichen wie bei hashMap
Hashtable ist eine threadsichere Sammlung und läuft langsam
HashMap ist eine Thread-unsichere Sammlung und läuft schnell

Hashtable hat das gleiche Schicksal wie Vector. Ab JDK1.2 wurde es durch die fortschrittlichere HashMap ersetzt

HashMap ermöglicht das Speichern von Nullwerten. Nullschlüssel
Hashtable erlaubt das Speichern von Nullwerten nicht, Nullschlüssel

Hashtable Seine untergeordneten und untergeordneten Klasseneigenschaften sind noch in der Entwicklungsphase aktiv

LinkedHashMap-Sammlungsfunktionen
java.util.LinkedHashMap erweitert HashMap implementiert Map
Funktionen der LinkedHashMap-Sammlung:
1. Hash-Tabelle + verknüpfte Liste: doppelt verknüpfte Liste, die die Iterationsreihenfolge garantieren kann
2. Schlüssel kann nicht wiederholt werden

Collections
java.util.Collections: Tool-Klasse zum Betreiben von Collection
Die Methoden in der Tool-Klasse sind alle statische Methoden und können direkt über die verwendet werden Klassenname

public static void sort(List list) // Die Sammlungselemente sortieren
public static void shuffle(List list) // Den Speicherort mischen der Sammlungselemente

Variable Parameter
Neue Funktionen, die nach JDK1.5 erschienen sind
Voraussetzung für die Verwendung: Der Datentyp der Methodenparameter ist festgelegt, die Anzahl der Parameter ist jedoch unsicher

Verwendung des Formats :
Modifikator Rückgabewerttyp Methodenname (Datentyp... Variablenname) {
}
... stellt dar, dass die Methode mehrere Parameter von empfangen kann derselbe Datentyp
Die unterste Ebene des variablen Parameters kann als Array behandelt werden

Hinweise zu variablen Parametern:
1. Für die Parameter einer Methode nur einer Variable Parameter können verwendet werden
2. Wenn die Parameter der Methode mehrere sind, müssen variable Parameter am Ende der Parameterliste geschrieben werden

 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     }

Statischer Import
JDK1.5 neue Funktion, statischer Import
Reduzieren Sie die Menge des entwickelten Codes
Standardschreibmethode, kann nur beim Importieren eines Pakets verwendet werden
statisches java.lang.System importieren .out; Am Ende muss es ein statisches Mitglied sein

package cn.itcast05;

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

  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 }

Das obige ist der detaillierte Inhalt vonWas ist eine Kartensammlung? Eigenschaften von Kartensammlungen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!