疯狂java


您现在的位置: 疯狂软件 >> 新闻资讯 >> 正文

Java集合【Map、可变参数、Collections】


 

 Java集合【Map、可变参数、Collections】

 
Map集合的特点
java.util.Map<K,V>接口:集合,是一个双列集合
Map集合的特点:
1.是一个双列集合,赋值的时候必须同时给key和value赋值
2.是一个无序的集合(存入和取出元素的顺序可能不一致)
3.key值不能重复,value可以重复
4.一个key只能对应一个vlaue
5.定义集合时,数据类型key和value可以使用相同的数据类型,也可以使用不同的数据类型
 
Map集合遍历的第一种方式
Map集合遍历的第一种方式:通过健查找值的方式
Map集合中有一个方法:keySet
Set<K> keySet() 返回此映射中包含的键的 Set 视图。 把Map集合中的健存储到一个Set集合中
遍历Map集合的步骤:
1.定义一个Map集合,往集合中添加元素
2.调用Map集合中的方法keySet,把Map集合中的健存储到一个Set集合中
3.遍历Set集合,获取Map集合所有的健
4.通过获取到的健,使用Map集合的方法get查找值
 
复制代码
 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     }
复制代码
Map集合遍历的第二种方式
Map集合遍历的第二种方式:遍历键值对的方式
Map集合中有一个方法:entrySet
Set<Map.Entry<K,V>> entrySet() 返回此映射中包含的映射关系的 Set 视图。 
遍历步骤:
1.定义一个Map集合,往集合中添加元素
2.调用Map集合中的方法entrySet,把Map集合中的每一个映射关系(结婚证)放入到Set集合中
3.遍历Set集合,获取每一个映射关系Entry<K,V>
4.使用Entry<K,V>中的方法getKey和getValue获取健和值
 
复制代码
 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存储自定义类型键值
HashMap存储自定义类型键值
自定义类型作为Map集合的值
自定义类型作为Map集合的健
 
记住:自定义类型什么时候重写hashCode和equals
1.使用HashSet存储自定义类型
2.使用HashMap集合,健使用自定义类型
 
Hashtable
Map 的实现类 Hashtable
底层数据结构是哈希表,特点和 hashMap 是一样的
Hashtable 是线程安全的集合,运行速度慢
HashMap 是线程不安全的集合,运行速度快
 
Hashtable 命运和 Vector 是一样的,从 JDK1.2 开始,被更先进的 HashMap 取代
 
HashMap 允许存储 null 值,null 健
hashtable 不允许存储 null 值,null 健
 
Hashtable 他的孩子,子类 Properties 依然活跃在开发舞台
 
LinkedHashMap集合特点
java.util.LinkedHashMap extends HashMap implements Map
LinkedHashMap集合特点:
1.哈希表+链表:双向链表,可以保证迭代顺序
2.key不能重复
 
 
Collections
java.util.Collections:操作Collection集合的工具类
工具类里边的方法都是静态方法,通过类名可以直接使用
 
public static <T> void sort(List<T> list) // 集合元素排序
public static void shuffle(List<?> list) // 集合元素存储位置打乱
 
可变参数
JDK1.5之后出现的新特性
使用前提:方法参数的数据类型确定,但是参数的个数不确定
 
使用格式:
修饰符 返回值类型 方法名(数据类型...变量名){
}
...代表方法可以接收同种数据类型的多个参数
可变参数的底层可以看成是一个数组
 
可变参数的注意事项:
1.一个方法的参数,只能使用一个可变参数
2.如果方法的参数有多个,可变参数必须写在参数列表的末尾
 
复制代码
 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     }
复制代码
静态导入
JDK1.5新特性,静态导入
减少开发的代码量
标准写法,导入包的时候才能使用
import static java.lang.System.out; 最末尾,必须是一个静态成员
 
package cn.itcast.demo05;
 
import java.util.ArrayList;
import java.util.Collections;
import 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      * 返回值类型:void
108      * 方法名:lookPoker
109      * 参数列表:玩家和底牌的集合,存储排的Map集合
110      * 使用查表法看牌:
111      *     遍历List集合,获取Map集合key,使用key去Map集合中查找value
112      */
113     public static void lookPoker(String name,ArrayList<Integer> list,HashMap<Integer,String> map){
114         System.out.print(name+":");
115         //遍历List集合,获取Map集合key
116         for (Integer key : list) {
117             //使用key去Map集合中查找value
118             String value = map.get(key);
119             System.out.print(value+" ");
120         }
121         System.out.println();//换行
122     }
123 }