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)。

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

遍历

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

 Entry键值对对象

public static void method04(){
        Map<String,String> map =new HashMap<String,String>();
        map.put("黄晓明", "baby"); //添加
        map.put("邓超", "孙俪");
        map.put("李晨", "范冰冰");
        map.put("徐峥", "桃红");
        //遍历结婚证
    /*    1、先获得结婚证存有set集合
        2、遍历结婚证集合得到每一个集合 
        3、得到每一个结婚证以后获取这个结婚证中的男方和女方  */
        Set<Map.Entry<String, String>> se = map.entrySet();
        for(Map.Entry<String, String> entry:se){
            System.out.println(entry.getKey()+entry.getValue());
        }
    }
　　　　2种方法
    public static void method05(){
        Map<String,String> map =new HashMap<String,String>();
        map.put("黄晓明", "baby"); //添加
        map.put("邓超", "孙俪");
        map.put("李晨", "范冰冰");
        map.put("徐峥", "桃红");
        Set<Map.Entry<String, String>> se = map.entrySet();
        for(Iterator<Entry<String, String>> it= se.iterator();it.hasNext();){
            Entry<String, String> str =it.next();
            System.out.println(str);
        }
    }

可变参数

在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集合工具类

模拟斗地主发牌练习

/*    //构造扑克牌
        HashMap<Integer,String> pooker =new HashMap<Integer,String>();
        //用于存扑克牌map中的key，洗牌的时候用
        ArrayList<Integer> pookenumber =new ArrayList<Integer>();
        //封装一副扑克牌
        //定义花色数组
        String[] color={"♣","♥","♦","♠"};
        //定义数字数组
        String[] number ={"2","A","3","4","5","6","7","8","9","10","J","Q","k"};
        int index =2;
        for(String num:number){
            for(String c:color){
                //将花色与数字结合存入map
                pooker.put(index, c+num);
                pookenumber.add(index);
                index++;
            }    
        }
        pooker.put(0, "大王");
        pookenumber.add(0);
        pooker.put(1, "小王");
        pookenumber.add(1);
        Set<Integer> set =pooker.keySet();
        for(Integer i:set){
            System.out.println(i+"..."+pooker.get(i));
        }
        //洗牌
        Collections.shuffle(pookenumber);
        ArrayList<Integer> player1=new ArrayList<Integer>();
        ArrayList<Integer> player2=new ArrayList<Integer>();
        ArrayList<Integer> player3=new ArrayList<Integer>();
        ArrayList<Integer> bottom=new ArrayList<Integer>();
        for(int i =0;i<pookenumber.size();i++){
            if(i<3){
                bottom.add(pookenumber.get(i));
            }else if(i%3==0){
                player1.add(pookenumber.get(i));
            }else if(i%3==1){
                player2.add(pookenumber.get(i));
            }else if(i%3==2){
                player3.add(pookenumber.get(i));
            }
        }
        //给玩家手里的牌排序
        Collections.sort(player1);
        Collections.sort(player2);
        Collections.sort(player3);
        Collections.sort(bottom);
        look("玩家一",player1,pooker);
        look("玩家二",player2,pooker);
        look("玩家三",player3,pooker);
        look("底牌",bottom,pooker);*/
        

/*public static void look(String name,ArrayList<Integer> player,
            HashMap<Integer,String>map){
        System.out.println(name+":");
        for(Integer num:player){
            System.out.print(map.get(num));
            
        }
        System.out.println();
    }*/