• 对于双列集合map的学习

    双列集合

    特点

    1.双列集合一次需要存一对数据，分别是键和值。

    2.键和值一一对应，键不能重复，值能重复。

    3.键+值这个整体我们称之为键值对或者键值对对象，在java中叫做Entry对象。

    Map的常见API

    Map是双列集合的顶层接口，它的功能是全部双列集合都可以继承使用的

    1. package MyApi.myMap;
    2. import java.util.HashMap;
    3. import java.util.Map;
    4. public class a01mymapdemo01 {
    5.     public static void main(String[] args) {
    6.         //1.创建map集合对象
    7.         Map m = new HashMap<>();
    8.         //2.添加元素
    9.         //put方法细节：
    10.         //添加/覆盖
    11.         //在添加数据的时候，如果键不存在，那么直接把键值对对象添加到map集合当中，方法返回null
    12.         //在添加数据的时候，如果键是存在的，那么会把原有的键值对对象覆盖，会把覆盖的值进行返回
    13.         m.put("郭靖", "黄蓉");
    14.         m.put("韦小宝", "沐剑屏");
    15.         m.put("尹志平", "小龙女");
    16.         //3.打印
    17.         //System.out.println(m);
    18.         //删除
    19.         String remove = m.remove("郭靖");
    20.         System.out.println(remove);
    21.         //清空
    22.         m.clear();
    23.         //判断是否包含
    24.         boolean key = m.containsKey("郭靖");
    25.         System.out.println(key);
    26.         //值是否包含
    27.         boolean containsValue = m.containsValue("小龙女");
    28.         System.out.println(containsValue);
    29.         //判断集合是否为空
    30.         boolean empty = m.isEmpty();
    31.         System.out.println(empty);
    32.         //集合的长度
    33.         int size = m.size();
    34.         System.out.println(size);
    35.     }
    36. }

    map集合的遍历方式

    1.键找值

    1. package MyApi.myMap;
    2. import java.util.HashMap;
    3. import java.util.Map;
    4. import java.util.Set;
    5.  
    6. public class a02Mapdemo02 {
    7.     public static void main(String[] args) {
    8.         //1.创建集合对象
    9.         Map  map=new HashMap<>();
    10.         //2.添加元素
    11.         map.put("郭靖", "黄蓉");
    12.         map.put("韦小宝", "沐剑屏");
    13.         map.put("尹志平", "小龙女");
    14.         //3.通过键找值
    15.         //3.1获取所有的键，把这些键放到一个单列集合当中
    16.       Set keys=  map.keySet();
    17.       //3.2遍历每一个集合，得到每一个键
    18.         for (String key : keys) {
    19.             System.out.println(key);
    20.             //3.3利用map集合中的键获取对应的值
    21.             String value = map.get(key);
    22.             System.out.println(key+"="+value);
    23.  
    24.         }
    25.     }
    26. }

    2.键值对

    1. package MyApi.myMap;
    2. import java.util.HashMap;
    3. import java.util.Map;
    4. import java.util.Set;
    5. public class a03Mapdemo03 {
    6.     public static void main(String[] args) {
    7.         //1.创建集合对象
    8.         Map  map=new HashMap<>();
    9.         //2.添加元素
    10.         map.put("郭靖", "黄蓉");
    11.         map.put("韦小宝", "沐剑屏");
    12.         map.put("尹志平", "小龙女");
    13.         //3.通过键值对对象
    14.         //3.1获取所有的键值对对象，返回一个set集合
    15.         Set> entries = map.entrySet();
    16.         //3.2遍历entries这个集合，去得到里面的每一个键值对对象
    17.         for (Map.Entry entry : entries) {
    18.             //3.3利用entry调用get方法获取键和值
    19.             String key = entry.getKey();
    20.             String value = entry.getValue();
    21.             System.out.println(key+"="+value);
    22.         }
    23.     }
    24. }

    3.Lamdba表达式

    1. package MyApi.myMap;
    2. import java.util.HashMap;
    3. import java.util.Map;
    4. import java.util.function.BiConsumer;
    5. public class a04mymapdemo04 {
    6.     public static void main(String[] args) {
    7.         //1.创建map集合的对象
    8.         Map map=new HashMap<>();
    9.         //2.添加元素
    10.         map.put("郭靖", "黄蓉");
    11.         map.put("韦小宝", "沐剑屏");
    12.         map.put("尹志平", "小龙女");
    13.         //3.利用lamabda表达式进行遍历
    14.         //底层：
    15.         //foreach其实就是利用第二种方式进行遍历，依次得到每一个键和值
    16.         //在调用accept方法
    17.         map.forEach(new BiConsumer() {
    18.             @Override
    19.             public void accept(String key, String value) {
    20.                 System.out.println(key+"="+value);
    21.             }
    22.         });
    23.         System.out.println("--------");
    24.         map.forEach((String key, String value)-> System.out.println(key+"="+value)
    25.         );
    26.     }
    27. }

    HashMap

    1.HashMap是map里面的一个实现类

    2.没有额外需要学习的特有方法，直接使用map里面的方法就可以了

    3.特点都是由键决定的：无序、不重复、无索引

    4.HashMap跟HashSet底层原理一模一样，都是哈希表结构

    5.依赖hashCode方法和equals方法保证键的唯一性

    6.如果键存储的是自定义对象，需要重写hashCode和equals方法，如果值存储自定义对象，不需要重写hashCode和equals方法。

    1. package MyApi.myMap;
    2. import java.util.HashMap;
    3. import java.util.Set;
    4.  
    5. public class a05hashmapdemo05 {
    6.     public static void main(String[] args) {
    7. //1.创建hashMap对象
    8.         HashMap hm=new HashMap<>();
    9.         //2.创建三个学生对象
    10.         Student s1=new Student("karry",24);
    11.         Student s2=new Student("roy",23);
    12.         Student s3=new Student("jackson",23);
    13.    //3.添加元素
    14.         hm.put(s1,"重庆");
    15.         hm.put(s2,"重庆");
    16.         hm.put(s3,"湖南");
    17.         //4.遍历集合
    18.         Set keys= hm.keySet();
    19.         for (Student key : keys) {
    20.             String value = hm.get(key);
    21.             System.out.println(key+"="+value);
    22.  
    23.         }
    24.  
    25.     }
    26. }
    1. package MyApi.myMap;
    2.  
    3. import java.util.*;
    4.  
    5. public class a06hashmapdemo06 {
    6.     public static void main(String[] args) {
    7.      //1.需要先让同学们投票
    8.      String[] arr={"a","b","c","d"};
    9.         ArrayList list=new ArrayList<>();
    10.         Random r=new Random();
    11.         for (int i = 0; i < 80; i++) {
    12.            int index= r.nextInt(arr.length);
    13.           //  System.out.println(arr[index]);
    14.             list.add(arr[index]);
    15.         }
    16.         //2.统计
    17.         HashMap hm=new HashMap<>();
    18.         for (String name : list) {
    19.             if(hm.containsKey(name)){
    20.                 Integer count = hm.get(name);
    21.            count++;
    22.            hm.put(name,count);
    23.             }else{
    24.                 hm.put(name,1);
    25.             }
    26.         }
    27.         System.out.println(hm);
    28.         //3.求最大值
    29.         int max=0;
    30.         Set> entries = hm.entrySet();
    31.         for (Map.Entry entry : entries) {
    32.             Integer value = entry.getValue();
    33.            if(value>max) {
    34.                max=value;
    35.            }
    36.         }
    37.         System.out.println(max);
    38.         //4.判断那个景点和最大值一样，如果一样，打印出来
    39.         for (Map.Entry entry : entries) {
    40.             Integer value = entry.getValue();
    41.             if(value==max) {
    42.                 System.out.println(entry.getKey());
    43.             }
    44.         }
    45.     }
    46. }

    LinkedHashMap

    • 由键决定：有序、不重复、无索引

    • 这里的有序是指保证存储和取出的元素顺序一致

    • 原理：底层数据结构依然是哈希表，只是每个键值对元素又额外多了一个双链表的机制记录存储的数据

    TreeMap

    • treemap和treeset底层原理一样，都是红黑树结构的

    • 由键决定特性：不重复、无索引、可排序

    • 可排序：对键进行排序

    • 注意：默认按照键的大小从小到大进行排序，也可以自己规定键的排序顺序

      代码书写两种排序规则

      • 实现Comparable接口，指定比较规则

      • 创建集合时传递Comparator比较器对象，指定比较规则。

      • 如果写的第一种也写了第二种则以第二种为准

        1. package MyApi.myMap;
        2.  
        3. import java.util.Comparator;
        4. import java.util.TreeMap;
        5.  
        6. public class a07Treesetdemo07 {
        7.     public static void main(String[] args) {
        8.         //1.创建集合对象
        9.         TreeMap tm=new TreeMap<>(new Comparator() {
        10.             @Override
        11.             public int compare(Integer o1, Integer o2) {
        12.                //o1表示要添加的元素
        13.                 //o2表示已经在红黑树中存在的元素
        14.                 return o2-o1;
        15.             }
        16.         });
        17.         tm.put(1,"奥利奥");
        18.         tm.put(2,"康师傅");
        19.         tm.put(3,"九个核桃");
        20.         tm.put(4,"雷碧");
        21.         tm.put(5,"可口可乐");
        22.         //3.
        23.         System.out.println(tm);
        24.     }
        25. }
        1. package MyApi.myMap;
        2.  
        3. import java.util.Objects;
        4.  
        5. public class Student implements  Comparable{
        6.     private String name;
        7.     private int age;
        8.  
        9.     public Student() {
        10.     }
        11.  
        12.     public Student(String name, int age) {
        13.         this.name = name;
        14.         this.age = age;
        15.     }
        16.  
        17.     public String getName() {
        18.         return name;
        19.     }
        20.  
        21.     public void setName(String name) {
        22.         this.name = name;
        23.     }
        24.  
        25.     public int getAge() {
        26.         return age;
        27.     }
        28.  
        29.     public void setAge(int age) {
        30.         this.age = age;
        31.     }
        32.  
        33.     @Override
        34.     public String toString() {
        35.         return "Student{" +
        36.                 "name='" + name + '\'' +
        37.                 ", age=" + age +
        38.                 '}';
        39.     }
        40.  
        41.     @Override
        42.     public boolean equals(Object o) {
        43.         if (this == o) return true;
        44.         if (o == null || getClass() != o.getClass()) return false;
        45.         Student student = (Student) o;
        46.         return age == student.age && Objects.equals(name, student.name);
        47.     }
        48.  
        49.     @Override
        50.     public int hashCode() {
        51.         return Objects.hash(name, age);
        52.     }
        53.  
        54.     @Override
        55.     public int compareTo(Student o) {
        56.         int i = this.getAge() - o.getAge();
        57.       i= i==0?this.getName().compareTo(o.getName()):i;
        58.         return i;
        59.     }
        60. }
        61. package MyApi.myMap;
        62.  
        63. import java.util.TreeMap;
        64.  
        65. public class a08treemapdemo08 {
        66.     public static void main(String[] args) {
        67.         TreeMap tm=new TreeMap<>();
        68.         Student s1=new Student("karry",24);
        69.         Student s2=new Student("roy",23);
        70.         Student s3=new Student("jackson",23);
        71.         tm.put(s1,"重庆");
        72.        tm.put(s2,"重庆");
        73.        tm.put(s3,"湖南");
        74.         System.out.println(tm);
        75.     }
        76. }
        1. 统计个数
        2. package MyApi.myMap;
        3.  
        4. import java.util.TreeMap;
        5. import java.util.function.BiConsumer;
        6.  
        7. public class a09treesedemo09 {
        8.     public static void main(String[] args) {
        9.        String s="aababcabcbdabcde";
        10.         TreeMap tm=new TreeMap<>();
        11.         for (int i = 0; i < s.length(); i++) {
        12.             char c = s.charAt(i);
        13. if(tm.containsKey(c)){
        14.   int count=tm.get(c)  ;
        15.   count++;
        16.   tm.put(c,count);
        17. }else {
        18.     tm.put(c,1);
        19. }
        20.         }
        21.     StringBuilder sb=new StringBuilder();
        22.         tm.forEach(new BiConsumer() {
        23.             @Override
        24.             public void accept(Character key, Integer value) {
        25.                 sb.append(key).append("(").append(value).append(")");
        26.             }
        27.         });
        28.         System.out.println(sb);
        29.     }
        30. }

  • 相关阅读:
    PostgreSQL之SQL高级特性
    Python爬虫脚本的基本组成
    Git详细介绍与SSH链接远程仓库
    vivo 容器集群监控系统架构与实践
    如何在 initial / task 等 begin_end 中等待某一个信号
    c++语言--面试题
    python操作MySQL、SQL注入问题、视图、触发器、事务、存储过程、函数、流程控制、索引(重点)
    Nuxt3区分环境打包报错“flase.appcet is not function“
    信创产业多点开花，AntDB数据库积极参与行业标准研制，协同价值链伙伴共促新发展
    Http CORS 跨域请求
  • 原文地址：https://blog.csdn.net/qq_52326978/article/details/136636240