java map接口，可变参数，Collections集合工具类

map接口的实现类存储成对的值，键——值。通过键来找到对应的值。

Collection中的集合称为单列集合，Map中的集合称为双列集合

Map中常用的集合为HashMap集合、LinkedHashMap集合。

HashMap<K,V>：存储数据采用的哈希表结构，元素的存取顺序不能保证一致。由于要保证键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。

LinkedHashMap<K,V>：HashMap下有个子类LinkedHashMap，存储数据采用的哈希表结构+链表结构。通过链表结构可以保证元素的存取顺序一致；通过哈希表结构可以保证的键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。

注意：Map接口中的集合都有两个泛型变量<K,V>,在使用时，要为两个泛型变量赋予数据类型。两个泛型变量<K,V>的数据类型可以相同，也可以不同

l put方法：将指定的键与值对应起来，并添加到集合中

n 方法返回值为键所对应的值

使用put方法时，若指定的键(key)在集合中没有，则没有这个键对应的值，返回null，并把指定的键值添加到集合中；

使用put方法时，若指定的键(key)在集合中存在，则返回值为集合中键对应的值（该值为替换前的值），并把指定键所对应的值，替换成指定的新值。

l get方法：获取指定键(key)所对应的值(value)

l remove方法：根据指定的键(key)删除元素，返回被删除元素的值(value)。

 1 public static void method01(){
 2         Map<String,String> map =new HashMap<String,String>();
 3         map.put("黄晓明", "baby"); //添加
 4         map.put("邓超", "孙俪");
 5         map.put("李晨", "范冰冰");
 6         map.put("徐峥", "桃红");
 7         map.put("徐峥", "红");
 8         //map.remove("徐峥");
 9         System.out.println(map.get("徐峥"));
10     }

遍历

 1 public static void method02(){
 2         Map<String,String> map =new HashMap<String,String>();
 3         map.put("黄晓明", "baby"); //添加
 4         map.put("邓超", "孙俪");
 5         map.put("李晨", "范冰冰");
 6         map.put("徐峥", "桃红");
 7         map.put("徐峥", "红");
 8         //遍历map集合
 9         //1、先获取所有存有map键的集合
10         //2、遍历set集合获取到每一个键
11         //3、根据键调用get方法获取到每一个值
12         //先创建一个set集合，调用keyset方法
13         Set<String> set =map.keySet();
14         //循环键，用get方法得到键所对应的值
15         for(Iterator<String> it=set.iterator();it.hasNext();){
16             System.out.println(map.get(it.next()));
17         }
18     }

Entry键值对对象

 1 public static void method04(){
 2         Map<String,String> map =new HashMap<String,String>();
 3         map.put("黄晓明", "baby"); //添加
 4         map.put("邓超", "孙俪");
 5         map.put("李晨", "范冰冰");
 6         map.put("徐峥", "桃红");
 7         //遍历结婚证
 8     /*    1、先获得结婚证存有set集合
 9         2、遍历结婚证集合得到每一个集合
10         3、得到每一个结婚证以后获取这个结婚证中的男方和女方  */
11         Set<Map.Entry<String, String>> se = map.entrySet();
12         for(Map.Entry<String, String> entry:se){
13             System.out.println(entry.getKey()+entry.getValue());
14         }
15     }　　　　2种方法
16     public static void method05(){
17         Map<String,String> map =new HashMap<String,String>();
18         map.put("黄晓明", "baby"); //添加
19         map.put("邓超", "孙俪");
20         map.put("李晨", "范冰冰");
21         map.put("徐峥", "桃红");
22         Set<Map.Entry<String, String>> se = map.entrySet();
23         for(Iterator<Entry<String, String>> it= se.iterator();it.hasNext();){
24             Entry<String, String> str =it.next();
25             System.out.println(str);
26         }
27     }

可变参数

在JDK1.5之后，如果我们定义一个方法需要接受多个参数，并且多个参数类型一致，我们可以对其简化成如下格式：

修饰符 返回值类型 方法名(参数类型... 形参名){  }

其实这个书写完全等价与

修饰符 返回值类型 方法名(参数类型[] 形参名){  }

只是后面这种定义，在调用时必须传递数组，而前者可以直接传递数据即可。

jdk1.5以后。出现了简化操作。... 用在参数上，称之为可变参数。

public static int add(int...arr){
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        return sum;
    }

Collections集合工具类

模拟斗地主发牌练习

 1 /*    //构造扑克牌
 2         HashMap<Integer,String> pooker =new HashMap<Integer,String>();
 3         //用于存扑克牌map中的key，洗牌的时候用
 4         ArrayList<Integer> pookenumber =new ArrayList<Integer>();
 5         //封装一副扑克牌
 6         //定义花色数组
 7         String[] color={"?","?","?","?"};
 8         //定义数字数组
 9         String[] number ={"2","A","3","4","5","6","7","8","9","10","J","Q","k"};
10         int index =2;
11         for(String num:number){
12             for(String c:color){
13                 //将花色与数字结合存入map
14                 pooker.put(index, c+num);
15                 pookenumber.add(index);
16                 index++;
17             }
18         }
19         pooker.put(0, "大王");
20         pookenumber.add(0);
21         pooker.put(1, "小王");
22         pookenumber.add(1);
23         Set<Integer> set =pooker.keySet();
24         for(Integer i:set){
25             System.out.println(i+"..."+pooker.get(i));
26         }
27         //洗牌
28         Collections.shuffle(pookenumber);
29         ArrayList<Integer> player1=new ArrayList<Integer>();
30         ArrayList<Integer> player2=new ArrayList<Integer>();
31         ArrayList<Integer> player3=new ArrayList<Integer>();
32         ArrayList<Integer> bottom=new ArrayList<Integer>();
33         for(int i =0;i<pookenumber.size();i++){
34             if(i<3){
35                 bottom.add(pookenumber.get(i));
36             }else if(i%3==0){
37                 player1.add(pookenumber.get(i));
38             }else if(i%3==1){
39                 player2.add(pookenumber.get(i));
40             }else if(i%3==2){
41                 player3.add(pookenumber.get(i));
42             }
43         }
44         //给玩家手里的牌排序
45         Collections.sort(player1);
46         Collections.sort(player2);
47         Collections.sort(player3);
48         Collections.sort(bottom);
49         look("玩家一",player1,pooker);
50         look("玩家二",player2,pooker);
51         look("玩家三",player3,pooker);
52         look("底牌",bottom,pooker);*/
53         

 1 /*public static void look(String name,ArrayList<Integer> player,
 2             HashMap<Integer,String>map){
 3         System.out.println(name+":");
 4         for(Integer num:player){
 5             System.out.print(map.get(num));
 6
 7         }
 8         System.out.println();
 9     }*/
10     

原文地址：https://www.cnblogs.com/wangrongchen/p/9130761.html