十一. Java集合（2）

已于 2022-08-02 16:32:53 修改
阅读量48 收藏
点赞数
分类专栏： # Java学习笔记整理 文章标签： java
于 2021-09-03 16:17:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36256590/article/details/120084458
版权

1. 集合重点——Map接口

Map --------

​ ——Hashtable < ——Properties

​ ——HashMap <—— LinkedHashMap

​ ——SortedMap <——TreeMap

一. Map 实现类

 1.2出现
* | --- Map：双列数据，用于存储具有key-value键值对的数据   ---- 类似于高中的函数： y = f(x)
*          |----HashMap:  作为Map的主要实现类；线程不安全，效率高； 可存储null的key和value
*               |----LinkedHashMap:   1.4出现；保证遍历map元素时可以按照添加的顺序实现遍历。
*                                  原因：在原有的HashMap底层结构基础上，添加了一对指针，指向前后两个元素。
*                                  对于频繁的遍历操作，此类执行效率高于HashMap
*         |----TreeMap: 保证按照添加的key-value进行排序，实现排序遍历。（按照key来排），底层红黑树（同HashSet）
*         |----Hashtable:  作为古老的实现类  1.0时最早出现；线程安全，效率低  加了synchronized; 不能存储null的key和value
*              |----Properties:常用来处理配置文件。key和value都是String类型
*
*       HashMap的底层： 数组+链表  （jdk7之前）
*                      数组+链表+红黑树  （jdk8）
* 面试题：
* 1. HashMap的底层实现原理？
* 2. HashMap和Hashtable的异同？
* 3. CurrentHashMap 与  Hashtable 的异同？
*      为应对多线程高并发场景，引入CurrentHashMap，分段锁原理


@Test
public void test1(){
    Map map = new HashMap();
   // map = new Hashtable<>();  此语句如下操作报空指针异常
    map.put(null, null);   // HashMap时可行

}

二. Map结构的理解

纵向来看，

key 唯一，无序， 可看成Set存；

value可重复，无序。 可看成Collection单列数据存

横向来看，

一个数据是一个Entry，Entry有两个属性。

Entry 无序，不可重复

Map中的key:无序、不可重复；使用Set存储所有的key --> key所在的类要重写equals()和hashCode()  以HashMap为例

Map中的value: 无序、可重复；使用Collection存储所有value  --> value所在的类需重写equals()

一个键值对：key-value构成了一个Entry对象。
 Map中的Entry: 无序、不可重复；使用Set存储所有entry

三. HashMap在jdk7中的底层实现原理

* 三. HashMap的底层实现原理？ 以jdk7为例说明：
*      HashMap map = new HashMap():
*      在实例化以后，底层创建了长度为16的一维数组Entry[] table。
*      ...可能已经执行过多次put...
*      map.put(key1, value1):
*      首先调用key1所在类的hashCode方法计算key1的哈希值，经过计算后，得到在Entry数组中的存放位置。
*      如果此位置上的数据为空，此时key1，value1直接添加成功。 ----情况1
*      如果此位置上的数据不为空，（意味着此位置上存在一个或多个数据（以链表形式存在）），比较key1和已经存在的一个或多个数据的哈希值：
*          如果key1与已经存在的数据的哈希值都不同，此时key1-value1添加成功；  ----情况2
*          如果key1与某个数据的hash值相同，那么继续比较：调用ke1所在类的equals()方法，比较：
*                                                  如果equals()返回false,此时key10value添加成功； ----情况3
*                                                  如果equals()返回true,使用value1去替换相同key的value值 ！ （实质修改操作）
*                                                  
*       补充： 关于情况2和情况3：此时key1-value1和原来的数据都以链表的形式存储。
*       
*       在不断的添加过程中，涉及到扩容问题：默认扩容方式为， 扩容为原来容量的2倍，将原有数据复制过来。

四. 在jdk8中的底层实现原理

*   jdk8中相较于jdk7在底层实现方面的不同：
*   1. new HashMap()：底层没有创建一个长度为16的数组；
*   2. jdk8底层的数组是： Node[]，而非Entry[]
*   3. 首次调用put()方法时，底层创建长度为16的数组；
*   4. jdk7底层结构只有 数组+链表；  jdk8中底层结构： 数组+链表+红黑树。
*      当数组的某一个索引位置上的元素以链表的形式存在的数据个数 > 8且当前数组长度 > 64时，此时索引位置上的所有数据改为使用红黑树存储。

五. HashMap jdk7底层源码分析

new 时，

① 无参构造器，创建长度为16的数组，默认加载因子0.75；

底层while循环自动左移2^n达到长度16。

② 临界值，超过12时开始扩容 （12 = 16 * 0.75）

put()时，

①判断是否为null，是也添加成功；

②涉及到hashCode()的调用，但不完全是。

③ 取与运算，而不是取模；获取存放位置；

④取出当前位置上的元素，若为null直接放新元素，调用addEntry()方法；

​ 若有值，比较hash值，不等添加成功；相等继续比较key是否相等，相等添加失败，新value覆盖旧value；不等添加成功。

调用addEntry()时，

①判断长度 > 12（临界值）且要存放的位置不为空，则扩容。扩为原来的2倍。所有元素重新放；

②不需要扩容，直接放元素到该位置上。存在旧元素则事先拿出来，作为新元素的下一个位置元素。

六. HashMap jdk8底层源码分析

transient Node<K,V>[] table;

put()

首次调用put，table是null，则调用resize（），创建数组16；

非首次调用，则①判断存的位置元素是否为null，是则直接添加成功；②存的位置不是null，则有元素，判断hash值是否相同，2.1 不同，跟该位置上其他元素继续比；2.2.1 相同，key也相同，则新元素的value替换到该位置上;2.2.2 相同，但key (equals)不同,跟next元素（链表上的其他元素）继续比，若都不同，则添加成功，有一个相同则添加失败，value替换；

若当前位置链表元素再添加会超过 8 , 先判断当前数组长度 < 64时，结构不改变，只扩个容；当元素再添加会超过 8且数组长度>64,则变为树形结构。

默认容量：16；

默认加载因子： 0.75 太小数组利用率低，太大链表结构太多

扩容临界值： 12 = 16 * 0.75

转化红黑树临界值： 8

数组表被树形结构化时最小的hash表容量： 64

2. LinkedHashMap的底层实现

* 四. LinkedHashMap的底层实现原理（了解）
*      为什么会按添加的顺序输出？
*      源码当中LinkedHashMap Entry内部类继承了HashMap的Node类，但多实现了一步：
*          Entry<K, V> before, after;   // 能够记录添加的元素的先后顺序
*      故输出时按添加的顺序输出

适合于频繁的遍历需求。

@Test
public void test2(){
    Map map = new LinkedHashMap();

    map.put(123, "AA");
    map.put(345, "BB");
    map.put(678, "CC");

    System.out.println(map); // 输出时按照添加的顺序输出
}

3. Map的常用方法

添加、删除、修改操作：
 Object put(Object key,Object value)：将指定key-value添加到(或修改)当前map对象中
 void putAll(Map m):将m中的所有key-value对存放到当前map中
 Object remove(Object key)：移除指定key的key-value对，并返回value
 void clear()：清空当前map中的所有数据

@Test
public void test3(){
    Map map = new HashMap();
    // 添加
    map.put("AA", 123);
    map.put(45, 123);
    map.put("BB", 123);
    // 修改
    map.put("AA", 456);

    System.out.println(map); // {AA=456, BB=123, 45=123}

    Map map1 = new HashMap();
    map1.put("CC", 123);
    map1.put("DD", 123);

    map.putAll(map1);
    System.out.println(map); // {AA=456, BB=123, CC=123, DD=123, 45=123}

    // remove(Object key)
    Object val = map.remove("CC");
    System.out.println(val); // 123
    System.out.println(map); // {AA=456, BB=123, DD=123, 45=123} 移除了CC

    // clear()
    map.clear(); // 清空数据，但map还在
    System.out.println(map.size()); // 0
    System.out.println(map); // {}
}

元素查询的操作：  Object get(Object key)：获取指定key对应的va 元素查询的操作：
 Object get(Object key)：获取指定key对应的value
 boolean containsKey(Object key)：是否包含指定的key
 boolean containsValue(Object value)：是否包含指定的value
 int size()：返回map中key-value对的个数
 boolean isEmpty()：判断当前map是否为空
 boolean equals(Object obj)：判断当前map和参数对象obj是否相等lue  boolean containsKey(Object key)：是否包含指定的key  boolean containsValue(Object value)：是否包含指定的value  int size()：返回map中key-value对的个数  boolean isEmpty()：判断当前map是否为空  boolean equals(Object obj)：判断当前map和参数对象obj是否相等

@Test
 public void test4(){
    Map map = new HashMap();
    // 添加
    map.put("AA", 123);
    map.put(45, 123);
    map.put("BB", 123);
    // Object get(Object key)：获取指定key对应的value
    System.out.println(map.get(45)); // 123  key不存在返回null
    // boolean containsKey(Object key)：是否包含指定的key
    boolean isExit = map.containsKey("BB");
    System.out.println(isExit);  // true

    boolean isExit1 = map.containsValue(123);
    System.out.println(isExit1);  // true

    map.clear();
    System.out.println(map.isEmpty());  // true
}

* 元视图操作的方法：
*  Set keySet()：返回所有key构成的Set集合
*  Collection values()： * 元视图操作的方法：
 *  Set keySet()：返回所有key构成的Set集合
 *  Collection values()：返回所有value构成的Collection集合
 *  Set entrySet()：返回所有key-value对构成的Set集合
*  Set entrySet()：返回所有key-value对构成的Set集合

@Test
public void test5(){
    Map map = new HashMap();
    map.put("AA", 123);
    map.put(45, 456);
    map.put("BB", 789);

    // 遍历所有的key集
    Set set = map.keySet();
    Iterator iter = set.iterator();
    while (iter.hasNext()){
        System.out.println(iter.next()); // AA BB 45
    }
    // 遍历所有的value集
    Collection coll = map.values();
    for (Object obj : coll){
        System.out.println(obj);  // 123  789  456    顺序与key一致
    }

    // 遍历所有的key-value
    // 方式一
    Set entrySet = map.entrySet();
    Iterator ite1 = entrySet.iterator();
    while (ite1.hasNext()){
        Object obj1 = ite1.next();  // Entry
        // entrySett集合中的元素都是entry,可强转
        Map.Entry entry = (Map.Entry) obj1;
        System.out.println(entry.getKey() + "---->" + entry.getValue());
    }
    //AA---->123
    //BB---->789
    //45---->456

    // 方式二
    Set keySet = map.keySet();
    Iterator iter2 = keySet.iterator();
    while (iter2.hasNext()){
        Object key = iter2.next();
        Object value = map.get(key);
        System.out.println(key + "====" + value);
    }
    //AA====123
    //BB====789
    //45====456
}
  • 总结常用方法：
  • 添加：put(Object key,Object value)
  • 删除：remove(Object key)
  • 修改：put(Object key,Object value)
  • 查询：get(Object key)
  • 长度：size()
  • 遍历：keySet() / values() / entrySet()

4. TreeMap两种添加方式的使用（了解）

// 向TreeMap中添加key-value，要求key必须是由同一个类创建的对象
// // 向TreeMap中添加key-value，要求key必须是由同一个类创建的对象
    // 因为要按照key进行排序，所以有自然排序、定制排序，所以有自然排序、定制排序

自然排序

@Test
public void test1(){
    TreeMap map = new TreeMap();
    User u1 = new User("Tom", 23);
    User u2 = new User("Jerry", 32);
    User u3 = new User("Jack", 20);
    User u4 = new User("Rose", 54);

    map.put(u1, 98);
    map.put(u2, 89);
    map.put(u3, 76);
    map.put(u4, 100);

    Set entrySet = map.entrySet();
    Iterator ite1 = entrySet.iterator();
    while (ite1.hasNext()){
        Object obj1 = ite1.next();  // Entry
        // entrySett集合中的元素都是entry,可强转
        Map.Entry entry = (Map.Entry) obj1;
        System.out.println(entry.getKey() + "---->" + entry.getValue());
    }
    // 自然排序
    // User{name='Jack', age=20}---->76
    //User{name='Jerry', age=32}---->89
    //User{name='Rose', age=54}---->100
    //User{name='Tom', age=23}---->98
}

定制排序

// 定制排序  按年龄从小到大排列
@Test
public void test2() {
    TreeMap map = new TreeMap(new Comparator() {
        @Override
        public int compare(Object o1, Object o2) {
            if (o1 instanceof User && o2 instanceof User) {
                User u1 = (User) o1;
                User u2 = (User) o2;
                return Integer.compare(u1.getAge(), u2.getAge());
            } else {
                throw new RuntimeException("输入的数据类型不匹配");
            }
        }
    });
    User u1 = new User("Tom", 23);
    User u2 = new User("Jerry", 32);
    User u3 = new User("Jack", 20);
    User u4 = new User("Rose", 54);

    map.put(u1, 98);
    map.put(u2, 89);
    map.put(u3, 76);
    map.put(u4, 100);

    Set entrySet = map.entrySet();
    Iterator ite1 = entrySet.iterator();
    while (ite1.hasNext()){
        Object obj1 = ite1.next();  // Entry
        // entrySett集合中的元素都是entry,可强转
        Map.Entry entry = (Map.Entry) obj1;
        System.out.println(entry.getKey() + "---->" + entry.getValue());
    }
}}

User{name=‘Jack’, age=20}---->76
User{name=‘Tom’, age=23}---->98
User{name=‘Jerry’, age=32}---->89
User{name=‘Rose’, age=54}---->100

5. Map实现类之Proterties——处理配置文件

/**
 *  |----Properties:常用来处理配置文件。key和value都是String类型
 */
public class PropertiesTest {
    public static void main(String[] args) {
        FileInputStream files = null;
        try{
            Properties pros = new Properties();
            // 默认工程下建配置文件
            files = new FileInputStream("123.properties");

            pros.load(files);
            String name = pros.getProperty("name");
            String password = pros.getProperty("password");

            System.out.println(name + "----" + password);
        }catch (IOException e){
            e.printStackTrace();
        } finally {
            if (files != null){
                try {
                    files.close();
                }catch (IOException e){
                    e.printStackTrace();
                }
            }
        }
    }
}

6. Collections常用工具类的测试

尚硅谷557课

Pisces_224
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值