Map案例练习

概述

1. Map：双列集合的顶层接口
2. Map：地图，在生活中，地图上的每一个点都对应着我们所在位置
3. Map：描述的就是一个数据（key）到另一个数据（value）的映射关系（对应关系）

  一个数据（key）：就是有规律的，容易记忆的，简单的一个数据

  另一个数据（value）：没有规律的，不容易记忆的，复杂的一个数据

  大多数都是根据key来寻找value

1. 映射：对应关系

  表达式方式：y = x * x

  穷举罗列：{1=1, 2=4, 3=9, 4=16, 5=25}

1. java中Map就是使用的穷举罗列的方式来描述映射关系
2. Map的特点：

  双列接口

一个key对应着一个value

没有顺序

Key可以为null，key是不能重复，value可以重复

1. Map和Collection的区别：

  Map双列集合，collection是单列结合

Map中的常用方法

1. 增加键值对：put(key,value);
2. 删除方法：remove(key);

  根据给定的键，删除对应的键值对：

  清空集合：clear()

1. 获取方法：

  获取集合的大小：size()

  根据给定的键，获取对应的值：                                                                                                                               

1. 判断方法：

  判断集合中是否存在某个键：containsKey(key)

  判断集合中是否存在某个值：containsValue(value)

1. 修改方法：

  根据给定的键，修改对应的值：put(key,value)

  如果在集合中已经存在key这个键，那么使用put方法，就是修改其对应的值；如果集合中不存在key这个键，那么使用put方法，就是在集合中增加了一个键值对

6、键值对的存储和获取没有顺序

Map集合的第一种遍历思路【熟练掌握】

1. 获取Map集合中的所有键，放到一个Set集合中，遍历该Set集合，获取到每一个键，根据键再来获取对应的值。【根据键获取值】
2. 获取Map集合中的所有键

  Set<K> keySet()

1. 遍历Set集合的两种方法：

  迭代器

  增强for循环

1. 拿到每个键之后，获取对应的值

  V get(K key)

1. 图示：

  

1. 特点：

  获取了所有的键的集合之后，仍然要依赖原来的Map集合

Map集合的第二种遍历思路【熟练掌握】

1. 获取Map集合中的所有键值对对象（Entry），到Set集合中，遍历Set集合，拿到的是每个键值对对象（Entry），从这个对象中分别获取键和值。【根据键值对对象获取键和值】
2. 根据Map集合获取所有的键值对对象，到一个Set集合中

  Set<Map.Entry<K, V>>  entrySet()

1. 遍历Set集合，两种遍历方式

  迭代器

  增强for循环

1. 获取到某个键值对对象

  Entry是Map接口中的内部接口，访问的方式：Map.Entry

  Entry：入口、条目、登记记录

  Entry的常用方法：

    getKey()获取当前键值对对象的键

    getValue()获取当前键值对对象的值

1. 图示：

   

 习题

1.分析以下需求，并用代码实现：
    (1)定义一个学生类Student，包含属性：姓名(String name)、年龄(int age)
    (2)定义Map集合，用Student对象作为key，用字符串(此表示表示学生的住址)作为value
    (3)利用四种方式遍历Map集合中的内容，格式：key::value

public class Student {
    private String name;
    private Integer age;

    public Student(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

 Map<Student,String> map = new HashMap<Student,String>();
        map.put(new Student("aaa",18),"南京");
        map.put(new Student("bbb",19),"上海");
        map.put(new Student("ccc",20),"武汉");
        map.put(new Student("ddd",18),"安徽");
        Set<Student>keys = map.keySet();
        //第一种方式
        Iterator<Student> it = keys.iterator();
        while(it.hasNext()) {
            Student key=it.next();
            System.out.println(key+"::"+map.get(key));
        }
        
         /*//第二种方法
        Set<Map.Entry<Student, String>> es=map.entrySet();
        Iterator<Map.Entry<Student, String>> it1 = es.iterator();
        while(it1.hasNext()) {
            Map.Entry<Student, String> en=it1.next();
            System.out.println(en.getKey()+"::"+en.getValue());
        }*/

        /* //第三种方法
        for(Student key:keys) {
            System.out.println(key+"::"+map.get(key));
        }*/

    

/*2.分析以下需求，并用代码实现：
    (1)利用键盘录入，输入一个字符串
    (2)统计该字符串中各个字符的数量
	(3)如：
    用户输入字符串"If~you-want~to~change-your_fate_I_think~you~must~come-to-the-ujiuye-to-learn-java"
    程序输出结果：-(9)I(2)_(3)a(7)c(2)d(1).....*/
    @Test
    public void test4(){
        Scanner sc=new Scanner(System.in);
        System.out.print("请输入字符串:");
        String str=sc.nextLine();
        char[] ch = str.toCharArray();
        Map<Character,Integer> map=new HashMap<>();
        for (int i = 0; i < ch.length; i++) {
            char key=ch[i];
            map.put(key, map.containsKey(key) ? map.get(key)+1 : 1);
        }
        Set<Character> keys = map.keySet();
        StringBuilder sb=new StringBuilder();
        for(Character key:keys) {
            sb.append(key+"("+map.get(key)+")");
        }
        System.out.println(sb);
    }

    /*3.分析以下需求，并用代码实现：
    (1)统计每个单词出现的次数
    (2)有如下字符串"If you want to change your fate I think you must come to the ujiuye to learn java"(用空格间隔)
    (3)打印格式：
    to=3
    think=1
    you=2*/
    @Test
    public void test5(){
        Map<String,Integer> map = new HashMap<String,Integer>();
        String str = "If you want to change your fate I think you must come to the ujiuye to learn java";
        String[] str1 = str.split(" ");
        for (int i = 0; i < str1.length; i++) {
            String key = str1[i];
            map.put(key, map.containsKey(key) ? map.get(key)+1 : 1);
        }
        Set<String>keys = map.keySet();
        for(String key:keys) {
            System.out.println(key+"="+map.get(key));
        }
    }

public class TestMethod {

    @Test
    public void test1(){
        List<String> list = new ArrayList();
        list.add("a");
        list.add("a");
        list.add("a");
        list.add("b");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("d");
        list.add("d");
        list.add("d");
        list.add("d");
        Map<String,Integer> map = new HashMap<String,Integer>();
        for (int i = 0; i < list.size(); i++) {
            String key = list.get(i);
            map.put(key, map.containsKey(key) ? map.get(key)+1 : 1);
        }
        for(String key:map.keySet()) {
            System.out.println(key+" 出现 "+map.get(key)+"次");
        }
    }

     /*2.分析以下需求，并用代码实现：
        (1)生成10个1至100之间的随机整数(不能重复)，存入一个List集合
        (2)编写方法对List集合进行排序
	    (3)然后利用迭代器遍历集合元素并输出
        (4)如：15 18 20 40 46 60 65 70 75 91*/
    @Test
    public void test2(){
        Random random = new Random();
        List<Integer> list = new ArrayList<Integer>();
        while (list.size()<10) {
            Integer num = random.nextInt(100)+1;
            if(!list.contains(num)){
                list.add(num);
            }
        }
        for (int i=0;i<list.size()-1;i++) {
            for (int j = 0; j < list.size() - i - 1; j++) {
                if (list.get(j) > list.get(j + 1)) {
                    int temp = list.get(j);
                    list.set(j, list.get(j + 1));
                    list.set(j + 1, temp);
                }
            }
        }
       // Collections.sort(list);
        Iterator<Integer> it = list.iterator();
        while (it.hasNext()){
            System.out.print(it.next()+" ");
        }
    }

     /*3.分析以下需求，并用代码实现：
       (1)定义List集合，存入多个字符串，其中包含三个连续的"def"
       (2)删除集合中字符串"def"
       (3)然后利用迭代器遍历集合元素并输出*/
     @Test
     public void test3(){
         List<String> list = new ArrayList<String>();
         list.add("aaa");
         list.add("sdw");
         list.add("defdef");
         list.add("aadefcc");
         list.add("aadefcc");
         list.add("aadefcc");
         list.add("bbb");
         list.add("ccc");
         list.removeIf(e->e.contains("def"));
         Iterator<String> it = list.iterator();
         while (it.hasNext()){
             System.out.print(it.next()+" ");
         }
     }

    /* 4.分析以下需求，并用代码实现：
        (1)定义List集合，存入多个字符串
        (2)删除集合中包含0-9数字的字符串(只要字符串中包含0-9中的任意一个数字就需要删除此整个字符串)
	    (3)然后利用迭代器遍历集合元素并输出*/
    @Test
    public void test4(){
        List<String> list = new ArrayList<String>();
        list.add("aafm");
        list.add("sw12w");
        list.add("jfhb");
        list.add("5j33h");
        list.add("cdwcc");
        list.add("8sjs4d");
        for (int i = 0; i < list.size(); i++) {
            String str = list.get(i);
            for (int j = 0; j < 10 ; j++) {
                if(str.contains(j+"")){
                    list.remove(i);
                    i--;
                    break;
                }
            }
        }
        Iterator it = list.iterator();
        while (it.hasNext()) {
            System.out.print(it.next() + " ");
        }
    }

   /* 5.随机生成10个20~40之间的随机数，存储在合适的集合中，并且进行遍历
    要求：随机数不能重复*/
   @Test
   public void test5(){
       Random random = new Random();
       HashSet<Integer> hs = new HashSet<Integer>();
       while (hs.size()<10) {
           int x = random.nextInt(21)+20;
           hs.add(x);
       }
       for (Integer item : hs) {
           System.out.print(item + " ");
       }
   }
}