Java 进阶：集合框架3

目录

一、Map 接口
1. Map 和 Collection
2. Map 接口中的常用方法
3. Map 集合遍历—— keySet方法
4. Entry 接口
5. Map 集合遍历——Entry
6. HashMap 存储自定义类型键值
二、集合继承体系的面向对象思想
三、数组和 List 的相互转化
1. Collction转化为数组

---

一、Map 接口

1. Map 和 Collection

• Collection 中的集合，元素是 孤立存在 的，向集合中存储元素采用一个个元素的方式存储

• Map 中的集合，元素是 成对 存在的。每个元素由 键 与 值 两部分组成，通过键可以找对所对应的值。

• Collection 中的集合称为 单列集合，Map 中的集合称为 双列集合

• Map中的集合 不能包含重复的键，值可以重复；每个键只能对应一个值

• Map 中常用的集合为：

• HashMap集合
  存储数据采用的哈希表结构，元素的存取顺序不能保证一致。由于要保证键的唯一、不重复，需要重写键的 hashCode()方法、equals()方法。

• LinkedHashMap集合。
  存储数据采用的哈希表结构+链表结构。通过链表结构可以保证元素的存取顺序一致；通过哈希表结构可以保证的键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。

• Map 接口中的集合都有两个泛型变量 <K,V> ,在使用时，要为两个泛型变量赋予数据类型。两个泛型变量<K,V>的数据类型可以相同，也可以不同。

2. Map 接口中的常用方法

• put(K key, V value)：将指定的键与值对应起来，并添加到集合中

• 方法返回值为键所对应的值

1. 使用put方法时，若指定的键(key)在集合中没有，则没有这个键对应的值，返回 null，并把指定的键值 添加 到集合中； 
2. 使用put方法时，若指定的键(key)在集合中 存在，则返回值为集合中键对应的值（该值为替换前的值），并把指定键所对应的值，替换 成指定的新值。
3.get(Object key) : 获取指定键(key)所对应的值(value)

• 如果集合中没有这个键,返回 null

• remove(Object key)：根据指定的键(key)删除元素，返回 被删除元素的值(value)

• 如果集合中没有这个键,返回 null

3. Map 集合遍历—— keySet方法

• keySet 方法：把所有的 键，存储到 Set集合

• 遍历步骤：

• 调用 map 集合的方法 keySet方法，把所有的键存储到 Set集合 中

• 遍历 Set集合，获取出 Set集合中的 所有元素 (Map中的键)

• 调用 map集合 get方法，通过键获取到值

public class MapDemo {
    public static void main(String[] args) {
    Map<String,Integer> map = new HashMap<String,Integer>();
    map.put("a", 11);
    map.put("b", 12);
    map.put("c", 13);
    map.put("d", 14);

    Set<String> set = map.keySet();
    Iterator<String> it = set.iterator();

    while(it.hasNext()){
        String key = it.next();
        Integer value = map.get(key);
        System.out.println(key+"...."+value);
    }

    //利用加强 for  遍历
    for(String key : map.keySet()){
        Integer value = map.get(key);
        System.out.println(key+"...."+value);
    }

4. Entry 接口

• 在Map类设计时，提供了一个嵌套接口：Entry。Entry将键值对的对应关系封装成了对象。即 键值对对象，这样我们在遍历Map集合时，就可以从每一个键值对（Entry）对象中获取对应的键与对应的值
• Entry是Map接口中提供的一个 静态内部嵌套接口
• Map.Entry(K, V)
• entrySet()方法：用于返回 Map 集合中所有的 键值对(Entry)对象，以 Set集合 形式返回。

5. Map 集合遍历——Entry

• 键值对方式： 即通过集合中每个 键值对(Entry)对象，获取键值对(Entry)对象中的键与值。

• 遍历步骤：

• 调用 map 集合方法 entrySet() ，将集合中的映射关系对象，存储到 Set集合

• 遍历 包含键值对(Entry)对象的 Set集合，得到每一个键值对(Entry)对象

• 通过键值对(Entry)对象，用 getKey、getValue 获取 Entry 对象中的 键与值。

Map集合不能直接使用 迭代器 或者 增强for 进行遍历。但是转成 Set 之后就可以使用了。

public class MapSet {
    public static void main(String[] args) {
        Map<Integer,String> map = new HashMap<>();
        map.put(1,"a");
        map.put(2,"ab");
        map.put(3,"abc");

        //调用 map 集合方法 entrySet()，将集合中的映射关系对象，存储到 Set集合
        Set<Map.Entry<Integer,String>> set = map.entrySet();
        //遍历Set集合
        Iterator<Map.Entry<Integer,String>> it = set.iterator();
        while(it.hasNext()){
            //获取Set集合中的元素，也就是映射关系对象
            //it.next 获取是 Map.Entry对象
            Map.Entry<Integer,String> entry =  it.next();
            //通过键值对(Entry)对象，用 getKey、getValue 获取 Entry 对象中的 键与值
            Integer key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key+" : "+value);
        }
    }
    //增强for循环
    for(Map.Entry<Integer,String> entry : map.entrySet()){
        System.out.println(entry.getKey()+" : "+entry.getValue());
    }
}

6. HashMap 存储自定义类型键值

• 当给HashMap中存放自定义对象时，如果自定义对象作为 key 存在，这时要保证 对象唯一，必须复写对象的 hashCode 和 equals方法
• 如果要保证map中存放的 key 和 取出的顺序一致，可以使用 LinkedHashMap 集合来存放。

---

二、集合继承体系的面向对象思想

• 接口：用来明确所有集合中该具有的功能，相当于在定义集合功能标准；
• 抽象类：把多个集合中功能实现方式相同的方法，抽取到抽象类实现，具体集合不再编写，继承使用即可；
• 具体类：继承抽象类，实现接口，重写所有抽象方法，达到具备指定功能的集合。每个具体集合类，根据自身的数据存储结构方式，对接口中的功能方法，进行不同方式的实现。

---

三、数组和 List 的相互转化

1. Collction转化为数组

• 用Arrays.asList 得到的List，不允许向其中添加元素，或者删除其中的元素，因为是 线程不安全的集合，必须转化为 线程安全 的集合
• Collections.synchronizedList(list)：将 list 转化为线程安全的集合
• Collections.synchronizedList(set)
• Collections.synchronizedList(map)

public class Supplement01 {
    public static void main(String[] args) {

        //int[] a = {1, 2, 3, 4};
        //将数组转化为集合
        List<Integer> list = Arrays.asList(1, 2, 3, 4);

        //添加元素，删除元素
        //用Arrays.asList得到的List，不允许向其中添加元素，或者删除其中的元素
        //list.add(5);
        //list.remove(0);

        //线程不安全的集合
        ArrayList<String> list1 = new ArrayList<>();

        //将线程不安全的集合转化为线程安全的集合
        //strings 就是一个线程安全的集合
        List<String> strings = Collections.synchronizedList(list1);

    }
}