java双列集合

双列集合

键值对对象（Entry）

特点：

1.双列集合一次需要存一堆数据，分别为键和值

2.键不能重复，值可以重复

3.键和值是一一对应的，每个键只能找到自己对应的值

4.键+值这个整体，我们称之为“键值对”或者“键值对象”，在Java中叫做“Entry对象”

体系结构

Map --> HashMap 、 TreeMap --> LinekedHashMap（继承子HashMap）

Map中常见的API

put（ K \ V） 添加元素

remove（object key） 删除键值对元素

clear 移除所有的键值对元素

containsKey（object key） 判断集合是否包含指定的键

containsValue（Object value） 判断集合是否包含指定的值

isEmpty 判断集合是否为空

size 集合的长度，也就是集合中键值对的个数

put方法

再添加数据的时候，如果键不存在，那么直接把键值对对象添加到map集合中，返回null，如果键是存在的，则会把原有的键值对覆盖，会返回被覆盖的值

remove方法

返回值是被删除的键值对的值

Map的遍历方式

1.通过键找值的方式遍历

public static void main(String[] args) {
        HashMap<String, String> m = new HashMap<>();
        m.put("11" , "55");
        m.put("22" , "66");
        m.put("33" , "77");
        m.put("44" , "88");
        // 1. 使用迭代器遍历
        // 1. 1 将Map中的所有的键存入到一个单列集合
        Set<String> hs = new HashSet<>();
        hs = m.keySet();
        Iterator<String> it = hs.iterator();
        while (it.hasNext()){
           String s = it.next();
            System.out.println(s + "-" + m.get(s));
        }
        // 2. 使用增强for遍历
        for (String h : hs) {
            System.out.println(h + "-" + m.get(h));
        }
        // 3. 使用lambda表达式遍历
        hs.forEach(h -> System.out.println(h + "-" + m.get(h)));
    }

2.通过键值对对象遍历

// 1. 迭代器方式遍历
        Set<Map.Entry<String, String>> entries = m.entrySet();
        Iterator<Map.Entry<String, String>> it = entries.iterator();
        Map.Entry e = null;
        while (it.hasNext()){
            e = it.next();
            System.out.println(e.getKey() + "++" + e.getValue());
        }
        // 2.增强for循环遍历
        for (Map.Entry<String, String> sse : m.entrySet()) {
            System.out.println(sse.getKey() + "--" + sse.getValue());
        }
        // 3. lambda遍历
        entries.forEach(entry -> System.out.println(entry.getKey() + "//" + entry.getValue()));
​

3.Map的遍历方式（lambda表达式）

forEach（BiConsumer< ? super K , ? super V> action） 结合lambda遍历Map集合

 entries.forEach(entry -> System.out.println(entry.getKey() + " +++" + entry.getValue()));

HashMap

是Map的实现类

键：无序、不重复（会覆盖原有的entry对象）、无索引

HashMap跟HashSet底层原理是一样的，都是哈希表结构（根据键计算出hash值即可）

依赖HashCode和equals方法保证键的唯一（如果键存储的是自定义对象）

LinkedHashMap：是HashMap的子类

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

保证存储和取出的元素顺序一致

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

TreeMap(底层基于红黑树实现排序，增删改查性能较好)

底层和tree底层原理一样，都是红黑树结构

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

可排序：对键进行排序

默认按照键从小到大进行排序，也可以自己规定键的排序规则

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

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

如果两种方式都存在，则主要以第二种方式比较

// TreeMap默认按照键升序，同时可以降序（需自己制定）
 TreeMap<Integer, String> isl = new TreeMap<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });
// 简化后的lambda
// 此为降序算法
//TreeMap<Integer, String> isl = new TreeMap<>((Integer o1, Integer o2) -> o2 - o1);
        Set<Map.Entry<Integer, String>> entries = isl.entrySet();
​
        isl.put(22435 , "23333");
        isl.put(234123 , "2222");
        isl.put(1223 , "233333333");
        entries.forEach(s -> System.out.println(s.getKey() + " +++" + s.getValue()));
    }
​

// TreeMap自定义排序规则
public int compareTo(Student o) {
        //this:表示当前要添加的元素
        //o：表示已经在红黑树中存在的元素
        //返回值
        //负数：表示当前要添加的元素是小的，存左边
        //正数：表示当前要添加的元素是大的，存右边
        //0：表示相同，舍弃
        // 比较的逻辑
    i = this.getAge() - o.getAge() ?
        return this.getAge() - o.getAge();
    }

利用map集合进行统计（K表示要统计的内容 - V 表示次数）

如果对结果不要求排序，默认使用HashMap

如果要求结果排序，使用TreeMap

// 统计字符出现次数 
// 1.定义需要统计的字符串
        String str = "giughiuahzzzzzzzzzzziasighuraghpoiaygreugasjhgfmzxkhigoai";
        // 2. 创建集合用来接收数据
        TreeMap<Character , Integer> tm = new TreeMap<>();
        // 3. 将转换成char的字符串诸葛放入集合
        for (int i = 0; i < str.length(); i++) {
            char a = str.charAt(i);
           if(tm.containsKey(a)){
                Integer count = tm.get(a);
                System.out.println(count);
                count += 1;
                tm.put(a , count);
            }else{
                tm.put(a , 1);
            }
        }
        System.out.println(tm);

String拼接字符串（在map的基础上进行拼接）

 //StringBuilder拼接字符串用法
        StringBuilder sb =