Java中Map集合的学习

Map

1.HashMap的特点
具备哈希特性：针对键，键唯一，无索引，无序
要求：键所属的类，覆盖重写hashCode和equals方法

2.LinkedHashMap的特点
具备哈希特性和链表特性，针对键
哈希特性：唯一，无索引
链表特性：有序
要求：键所属的类，覆盖重写hashCode和equals方法

3.Map的常用方法
public V put(K key, V value) : 把指定的键与指定的值添加到Map集合中。
public V remove(Object key) : 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的
值。
public V get(Object key) 根据指定的键，在Map集合中获取对应的值。
public Set keySet() : 获取Map集合中所有的键，存储到Set集合中。
public Set<Map.Entry<K,V>> entrySet() : 获取到Map集合中所有的键值对对象的集合(Set集合)。
public boolean containKey(Object key) :判断该集合中是否有此键。

package map;

/*
    java.util.Map<K,V>接口
        双列集合的根接口,里面定义的方法,子接口/实现类都有
        K: 键的类型     键 唯一
        V: 值的类型     值 可重复
        特点:
            1.键 唯一,值 可重复
            2.一个键对应一个值(一一对应关系,称为映射关系/键值对)
            3.通过键维护映射关系(只能通过键获取值,不能通过值获取键)

    常用实现类

        java.util.HashMap<K,V>集合
            特点:
                1.具备哈希特性: 针对键,键唯一,无索引,无序
                2.希特性: 唯一,无索引,无序
                3.要求: 键所属的类,覆盖重写hashCode方法和equals方法

        java.util.LinkedHashMap<K,V>集合
            特点:
                1.具备哈希特性+链表特性: 针对键
                2.哈希特性: 唯一,无索引
                3.链表特性: 有序
                3.要求: 键所属的类,覆盖重写hashCode方法和equals方法
    常用方法:
        - public V put(K key, V value):  把指定的键与指定的值添加到Map集合中。
            第一次存储该键: 返回 null
            已经存储过该键: 返回的被替换的值
            键重复,值替换

        - public V get(Object key) 根据指定的键，在Map集合中获取对应的值。
        - public V remove(Object key): 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值。
        - public boolean containKey(Object key):判断该集合中是否有此键。
        - public boolean containValue(Object value):判断该集合中是否有此值。
 */

import java.util.HashMap;
import java.util.Map;

public class Demo01 {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<>();
        String v = map.put("张三","李四");
        map.put("王五","赵六");
        map.put("张合","高览");

        v = map.put("张三","曹操");

        //System.out.println(map.get("张三"));

        String s = map.remove("张三");
        //System.out.println(s);

        System.out.println(map);
    }
}

4.Map集合获取所有的键和值

package map;

/*
    Map集合的获取所有的键和值的功能
        public Set<K> keySet(): 获取Map集合中所有的键组成的Set集合
        public Collection<V> values(): 获取Map集合中所有的值组成的Collection集合
*/

import java.util.*;

public class Demo02 {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<>();
        map.put("韩鹏","李金羽");
        map.put("曹操","曹丕");
        map.put("陆逊","孙权");

        Set<String> s = map.keySet();
        Iterator<String> it = s.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }

        Collection<String> v = map.values();
        Iterator<String> i = v.iterator();
        while (i.hasNext()){
            System.out.println(i);
        }

    }
}

5.Map集合的遍历
方式一：
通过键找到值

package map;

import java.util.HashMap;
import java.util.Map;

public class Demo03 {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<>();
        map.put("邓超","孙俪");
        map.put("李晨","范冰冰");
        map.put("刘德华","柳岩");

        for (String s:map.keySet()) {
            System.out.println(s+":"+map.get(s));
        }
    }
}

方式二：
通过键值对的方式

package map;

import java.util.HashMap;
import java.util.Map;

public class Demo04 {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<>();
        map.put("文章","马伊琍");
        map.put("刘德华","柳岩");
        map.put("范冰冰","李晨");

        for (Map.Entry<String,String> entry:map.entrySet()) {
            System.out.println(entry.getKey()+":"+entry.getValue());
        }
    }
}

6.用Map集合统计字符个数

package map;

import java.util.HashMap;
import java.util.Map;

public class Demo05 {
    public static void main(String[] args) {
        String str = "aacbdeeffabc";

        Map<Character,Integer> map = new HashMap<>();

        for (int i = 0; i < str.length() ; i++) {
            char ch = str.charAt(i);
            if (map.containsKey(ch)) {
                int num = map.get(ch);
                map.put(ch, ++num);
            } else {
                map.put(ch, 1);
            }
        }
        System.out.println(map);
    }
}

7.斗地主案例

package doudizhu;

import org.w3c.dom.ls.LSOutput;

import java.util.*;

public class Demo {
    public static void main(String[] args) {
        //1.存储扑克牌，花色和数字
        Map<Integer,String> map = new HashMap<>();
        List<String> colors = new ArrayList<>();
        List<String> nums = new ArrayList<>();
        Collections.addAll(colors,"♠","♥","♣","♦");
        Collections.addAll(nums,"3-4-5-6-7-8-9-10-J-Q-K-A-2".split("-"));

        int index = 0;//牌的索引
        //2.拼接花色和数字
        for (int i = 0; i < nums.size() ; i++) {
            for (int j = 0; j < colors.size() ; j++) {
                String pocks = nums.get(i) + colors.get(j);

                map.put(index++,pocks);
            }
        }

        map.put(index++,"大王");
        map.put(index,"小王");

        //3.打乱顺序,洗牌
        Set<Integer> set = map.keySet();
        ArrayList<Integer> list = new ArrayList<>(set);
        Collections.shuffle(list);

        //4.发牌
        ArrayList<Integer> p1 = new ArrayList<>();
        ArrayList<Integer> p2 = new ArrayList<>();
        ArrayList<Integer> p3 = new ArrayList<>();
        ArrayList<Integer> dipai = new ArrayList<>();

        for (int i = 0; i < list.size() ; i++) {
            if(i > 50){
                dipai.add(i);
            }else {
                if (i % 3 == 0){
                    p1.add(i);
                }else if (i % 2 == 0){
                    p2.add(i);
                }else {
                    p3.add(i);
                }
            }
        }

        lookPai("张三",p1,map);
        lookPai("李四",p1,map);
        lookPai("王五",p1,map);

    }

    //看牌
    public static void lookPai(String name,List<Integer> list,Map<Integer,String> map ){
        System.out.println(name + "的牌是");
        for (int a :list) {
            String b = map.get(a);
            System.out.println(b + ",");
        }
    }

}