集合框架之（Map集合）-阿里云开发者社区

注：面试常问：1.Map集合如何对字符串出现的次数进行排序？

2.Collection与Collections区别？

答：.Collection是单例集合的顶层接口，Collections是操作集合对象的工具类

3.HashMap与Hashtable区别？

一.Map集合的特点：

1.Map是一个双列集合，一个元素包含两个值（一个key，一个value）

2.Map中的元素，key不允许重复，value可以重复（覆盖）

3.Map里的key和value是一一对应的。

二.使用Map集合

编辑

实现源代码：

package com.lya.demo;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class Demo1 {
    /**
     * 如何使用Map集合(增删改查)
     */
    public static void main(String[] args) {
        // 新增
        Map<String, String> mp = new HashMap<>();
        String v1 = mp.put("诸君辆", "驷马一");
        System.out.println(v1);// key不重复，返回null
        String v2 = mp.put("诸君辆", "官宦请");
        System.out.println(v2);// key重复，返回v1的value
        mp.put("诸君辆2", "官宦请");
        System.out.println(mp);// {诸君辆2=官宦请, 诸君辆=官宦请}
        // 删除
        System.out.println("--------------删除------------");
        mp.remove("诸君辆2");
        System.out.println(mp);// 返回{诸君辆=官宦请}
        System.out.println("--------------是否包含键------------");
        // 判断集合中是否包含指定的键
        boolean containsKey = mp.containsKey("诸君辆");
        System.out.println(containsKey);//返回true
        System.out.println("--------------是否包含值------------");
        // 判断集合中是否包含指定的值
        boolean containsValue = mp.containsValue("官宦请");
        System.out.println(containsValue);//返回true
        // 修改
        System.out.println("--------------修改------------");
        System.out.println(mp);//{诸君辆=官宦请}
        mp.put("诸君辆", "晓晓");
        System.out.println(mp);//{诸君辆=晓晓}
    }
}

三、遍历Map集合的方式

存入一个Set集合来遍历Set集合

1.通过键找值的方法；

2.使用Entry对象遍历

编辑

四，如何对字符串出现的次数进行排序？

思路：1.我们可以将这个字符串进行分解成字符 2.再利用Map集合进行保存。 3.将字符作为Map的键进行对比如果Map集合中有了就加1，如果没有就设为1. 4.最后进行Map集合的遍历

实现效果：

编辑

实现代码：

package com.lya.demo;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
/**
 * 如何对字符串出现的次数进行排序 (asfdlkgiovnnaerlflkdfankasdfg)
 * @author 微微
 *
 */
public class Demo3 {
    public static void main(String[] args) {
        //提问：如何对字符串出现的次数进行排序？
        //思路：1.我们可以将这个字符串进行分解成字符
        //      2.再利用Map集合进行保存。
        //      3.将字符作为Map的键进行对比如果Map集合中有了就加1，如果没有就设为1.
        //      4.最后进行Map集合的遍历
        //1.定一个字符串
        String str = "asasfdlkgiovnnaerlflkdfankasdfg";
        //2.转换成字符
        char[] charArray = str.toCharArray();
        //3.定义一个存储字符的Map集合
        Map<Character, Integer> map = new HashMap<>();
        for (char c : charArray) {
            System.out.print(c+"\t");//得到所有的字符
        //4.将字符添加到map集合中作为键（因为map集合的键是不能重复）
            Integer integer = map.get(c);
            if(integer != null) {//map已经存在
                map.put(c, integer+1);
            }else {
                map.put(c, 1);
            }
        }
        //5.遍历Map集合
        for (Entry<Character, Integer> c : map.entrySet()) {
            System.out.println(c.getKey()+"出现"+c.getValue()+"次");
        }
    }
}

五，泛型

作用：

1.可以把运行中出现的错误提前在编译时展示出来。（我的理解就是方便找错，提示代码运行效率）

2.可以提高代码的健壮性。

编辑

代码：

package com.lya.demo;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
 * 泛型的应用 作用： 1.可以把运行中出现的错误提前在编译时展示出来。（我的理解就是方便找错，提示代码运行效率） 2.可以提高代码的健壮性。
 * 
 * @author 微微
 *
 */
public class Demo4 {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        list.add(66);
        list.add(221);
        //一个方法去获取list集合中的奇数。
        for (Object object : list) {
            //将objcet转成int类型
            if((int)object % 2 ==1) {
                System.out.println(object);//1  3   5   221
            }
        }
    }
}

六、集合工具Arrays,Cellections使用

package com.lya.map;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
 * 集合工具Arrays,Cellections使用
 * @author 微微
 *
 */
public class Demo5 {
  public static void main(String[] args) {
    //定义数组
    int arr [] = {333,2,32,333,1123,5};
    //使用：Arrays中的sort方法，就可以对数组进行排序。
    System.out.println("------------------------------------");
    Arrays.sort(arr);
    //如果我们不使用Array的toString方法就只能拿到内存地址。
    System.out.println(arr);//[I@26f0a63f
    System.out.println(arr.toString());//[I@26f0a63f
    System.out.println(Arrays.toString(arr));//[2, 5, 32, 333, 333, 1123]
    List<int[]> asList = Arrays.asList(arr);//aslist 可以将数组转成集合
    System.out.println("------------------------------------");
    List<Integer> list = new ArrayList<Integer>();
    list.add(1);
    list.add(3);
    list.add(32);
    list.add(9);
    Collections.sort(list);
    System.out.println();
  }
}

七、Map的常用实现类

（一）、HashMap

HashMap.特点：1.HashMap底是哈希表，查询速度非常快（jdk1.8之前是数组+单向链表，1.8之后是数组+单向链表/红黑树，链表长度超过8时，换成红黑树）

2. HashMap是无序的集合

【2】.HashMap存储自定义类型键值

HashMap存储自定义类型键值，Map集合保证key是唯一的：作为key的元素，必须重写hashCode方法和equals方法，以保证key唯一

（二）LinkedHashMap

HashMap有子类LinkedHashMap：LinkedHashMap <K,V> extends HashMap <K,V>

是Map接口的哈希表和链表的实现，具有可预知的迭代顺序（有序）

底层原理：哈希表+链表（记录元素顺序）

特点：1.LinkedHashMap底层是哈希表+链表（保证迭代的顺序）

2.LinkedHashMap是一个有序的集合，存储元素和取出元素的顺序一致

改进之处就是：元素存储有序了

(三）Hashtable

Hashtable<K,V> implements Map<K,V>

Hashtable：底层也是哈希表，是同步的，是一个单线程结合，是线程安全的集合，速度慢

HashMap：底层也是哈希表，但是线程不安全的集合，是多线程集合，速度快

HashMap（还有之前学的所有集合）：都可以存储null键，null值

Hashtable：不能存储null键，null值

（四）TreeMap

编辑

代码：

package com.lya.map;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;
/**
 * TreeMap使用
 * @author 微微
 *
 */
public class Demo6 {
    public static void main(String[] args) {
        //特点：1.以键排序（升，降）
        //      2.以值排序（升，降）
        //      3.Comparator.reverseOrder()     反转排序        
        Map<String, Object> map = new TreeMap<>(Comparator.reverseOrder());
        map.put("zhujunliang", 200);
        map.put("biaodi", 100);
        map.put("lix", 220);
        map.put("ww", 110);
        System.out.println(map);//输出{biaodi=100, lix=220, ww=110, zhujunliang=200}
        //可以得知TreeMap默认按照key升序
        //按照value
        Set<Entry<String,Object>> entrySet = map.entrySet();
        //将map转list
        ArrayList<Map.Entry<String, Object>> arrayList = new ArrayList<>(entrySet);
        //实现值所对应的比较器接口
        Collections.sort(arrayList,new Comparator<Entry<String, Object>>() {
            @Override
            public int compare(Entry<String, Object> o1, Entry<String, Object> o2) {
                // TODO Auto-generated method stub
                return o1.getValue().hashCode()-o2.getValue().hashCode();
            }
        });
        arrayList.forEach(System.out::println);//这里已经排序了按照升序！！！
    }
}

八、HashMap与Hashtable区别？

（一）Hashtable：同步 HashMap（异步）

同步：线程安全的（我的理解：做事有逻辑，例如我们穿好鞋再出门。同步即排队。）

异步：线程非安全。（我的理解：做事可以做多个，例如我们坐电梯时看消息。）

希望这篇文章能帮助到大家！！！😀

集合框架之（Map集合）