Java 9.0 各个集合的基本原理总结

最新推荐文章于 2023-06-16 14:46:56 发布
最新推荐文章于 2023-06-16 14:46:56 发布
阅读量174 收藏
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011676300/article/details/81013025
版权

基本特性

跳转目录

这里写图片描述

List

实现类父类数据结构是否线程安全扩容处理是否接受null值
LinkListAbstractSequentialList双向链表否接受多个null值
ArrayListAbstractList数组否1.5倍扩容接受多个null值
VectorAbstractList数组是自定义或者２倍扩容接受多个null值
StackVector数组是２倍扩容接受多个null值

Ｍap

Map主要用于存储健值对，根据键得到值，因此不允许键重复（重复了覆盖了），但允许值重复

实现类父类数据结构是否线程安全扩容处理是否接受null值其他
HashtableDictionary哈希表（数组）是２n+1key和value都不能为null值遍历时获取的数据是随机的
WeakHashMapAbstractMap哈希表 （数组）否２倍扩容key和value可为null值遍历时获取的数据是随机的
HashMapAbstractMap哈希表（单链表＋红黑树）否２倍扩容key和value可为null值遍历时获取的数据是随机的
LinkedHashMapHashMap哈希表（双向链表）否２倍扩容key和value可为null值遍历时获取的数据和插入时是一样的
TreeMapAbstractMap红黑树否key不能为null,value可以为null遍历时获取的数据是递增排序好的

Set

用于存储无序(存入和取出的顺序不一定相同)元素，值不能重复．
Set内部使用的是Ｍap实现，Ｍap的key不能重复，Set利用这一原理实现Set的元素值不重复．

实现类父类数据结构是否线程安全扩容处理是否接受null值其他
TreeSetAbstractSet（TreeMap实现）红黑树否２n+1元素不能为null值遍历时获取的数据是排序好的
HashSetAbstractSet(HashMap实现)哈希表 （单链表＋红黑树）否２倍扩容元素可为null值遍历时获取的数据是随机的
LinkHashSetHashSet(内部是LinkedHashMap实现)哈希表 （单链表＋红黑树）否２倍扩容元素可为null值遍历时获取的数据和插入时是一样的

1. List

跳转目录

LinkList是一个双向链表结构的集合．

1.1.1 继承体系

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable

1.1.2 私有变量

//元素数量
 transient int size = 0;
//头节点
transient Node<E> first;
//尾节点
transient Node<E> last;

1.1.3 数据结构

双向链表
下面是链表的节点定义．

private static class Node<E> {
   //元素值
    E item;
    //指向前驱节点
    Node<E> next;
    //指向后继节点
    Node<E> prev;
}

1.１.4 是否线程安全

非线程安全

1.１.4 迭代器

ListIterator

1.1.5 是否接受null值

接受多个null值

1.2 ArrayList

跳转目录

1.2.1 继承体系

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable

1.2.2私有变量

//初始容量
private static final int DEFAULT_CAPACITY = 10;
private static final Object[] EMPTY_ELEMENTDATA = {};
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
//保存数据的数组
transient Object[] elementData; 
//list的数据量
private int size;
//用于迭代时检测当前数组是否有更新
protected transient int modCount = 0;

1.2.3数据结构

ArrayList使用数组保存数据．

1.2.4扩容处理

当容量超过当前数据的长度时，ArrayList便会进行扩容．

获取新的容量，进行的是1.5倍扩容．

 private int newCapacity(int minCapacity) {
   // overflow-conscious code
    int oldCapacity = elementData.length;
    //1.5倍扩容
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity <= 0) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return minCapacity;
    }
    return (newCapacity - MAX_ARRAY_SIZE <= 0)
        ? newCapacity
        : hugeCapacity(minCapacity);
}

扩容处理，也就是实现数组复制

private Object[] grow(int minCapacity) {
    return elementData = Arrays.copyOf(elementData,
                                       newCapacity(minCapacity));
}

1.2.５迭代器访问

注意迭代过程中其他线程不能修改ArrayList

ArrayList<Integer> list = new ArrayList<Integer>();
list.add(234);
list.add(121);

//foreach
for(Integer dat:list){

    System.out.println(dat);
}

System.out.println();
//Iterator
Iterator it = list.iterator();
while(it.hasNext())
{
    System.out.println(it.next());
}
System.out.println();
//ListIterator
ListIterator listIterator = list.listIterator();
while(listIterator.hasNext())
{
    listIterator.add(123);
    System.out.println(listIterator.next());
}

1.2.6 是否线程安全

非线程安全

1.2.7 是否接受null值

可接受多个null值．

1.3 Vetor

跳转目录

1.3.1 继承体系

public class Vector<E>
    extends AbstractList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable

1.3.2 数据结构

使用数组保存数据

1.3.3 私有属性

//保存数据的数组
protected Object[] elementData;
//当前元素的数量
protected int elementCount;
//自定义每次扩容时增加的容量
protected int capacityIncrement;
//serialVersionUID
private static final long serialVersionUID = -2767605614048989439L;

1.3.4 扩容处理

每次添加元素时如果容量不够便会进行扩容处理．
获取新容量：
１．如果已经定义了每次扩容所增加的容量，那么扩容后的总容量就是当前的容量与自定义增加容量之和．
２．如果没定义，那就是两倍扩容．

 private int newCapacity(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    //获取新容量
    int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                     capacityIncrement : oldCapacity);
    if (newCapacity - minCapacity <= 0) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return minCapacity;
    }
    return (newCapacity - MAX_ARRAY_SIZE <= 0)
        ? newCapacity
        : hugeCapacity(minCapacity);
}

扩容处理，就是以新的容量复制旧的数组．

private Object[] grow(int minCapacity) {
        return elementData = Arrays.copyOf(elementData,
                                           newCapacity(minCapacity));
    }

1.3.4 迭代器访问

public  static void main(String[] args) {

  //list
  Vector<Integer> vector = new Vector<Integer>();
  vector.add(234);
  vector.add(121);
  vector.add(null);
  vector.add(null);
  //foreach
  for(Integer dat:vector){
      System.out.println(dat);
  }
  System.out.println();
  //Iterator
  Iterator it = vector.iterator();
  while(it.hasNext())
  {
      System.out.println(it.next());
  }
  System.out.println();
 //ListIterator
  ListIterator listIterator = vector.listIterator();
  while(listIterator.hasNext())
  {
      listIterator.add(123);
      System.out.println(listIterator.next());
  }
}

1.3.5 是否线程安全

Vector使用synchronized同步了部分方法，因此是线程安全的．

1.3.6 是否接受null值

可以接受多个null值．

1.4 Stack

跳转目录
Stack是Vector的子类，是一个栈，因此特性和上述的Vector一致．
相关方法

//构造器
 public Stack() {   };
 //向栈顶插入元素
 public E push(E item){};
 //弹出栈顶的元素（删除元素）
 public synchronized E pop(){} ;
 //获取栈顶的元素（不删除元素）
 public synchronized E peek()
 //检测栈是否为空
 public boolean empty() 
 //获取元素的索引
 public synchronized int search(Object o);

2 HashMap

2.1 Hashtable

跳转目录

2.1.1 继承体系

跳转目录

extends Dictionary<K,V>
    implements Map<K,V>, Cloneable, java.io.Serializable

2.1.2 私有变量

//保存各个节点的哈希表
private transient Entry<?,?>[] table;
//元素节点的数量
private transient int count;
//rehashed阀值，当元素数量大于threshold　＝　(int)(capacity * loadFactor)进行rehashed
private int threshold;
//加载因子
private float loadFactor;
//记录当前对集合修改的次数，实现fail-fast机制
private transient int modCount = 0;
//序列化ｉd
private static final long serialVersionUID = 1421746759512286392L;

2.1.3 保存结构

Entry是一个单链表结构

private transient Entry<?,?>[] table;
 private static class Entry<K,V> implements Map.Entry<K,V> {
    final int hash;
    final K key;
    V value;
    Entry<K,V> next;
 }

2.1.4 实现原理

使用哈希表进行保存．
计算每个key的哈希值，通过哈希值计算保存位置索引值index.再存入table中，如果出现哈希冲突，则使用链地址法解决．多个元素节点Entry在同一个index处形成单链表．

2.1.5 index值计算

int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF) % tab.length;

2.1.6rehash处理

可以看出，使用两倍扩容

protected void rehash() {
    int oldCapacity = table.length;
    Entry<?,?>[] oldMap = table;

    // overflow-conscious code
    //新容量是旧容量的两倍
    int newCapacity = (oldCapacity << 1) + 1;
    if (newCapacity - MAX_ARRAY_SIZE > 0) {
        if (oldCapacity == MAX_ARRAY_SIZE)
            // Keep running with MAX_ARRAY_SIZE buckets
            return;
        newCapacity = MAX_ARRAY_SIZE;
    }
    Entry<?,?>[] newMap = new Entry<?,?>[newCapacity];

    modCount++;
    threshold = (int)Math.min(newCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
    table = newMap;
　　　//复制节点
    for (int i = oldCapacity ; i-- > 0 ;) {
        for (Entry<K,V> old = (Entry<K,V>)oldMap[i] ; old != null ; ) {
            Entry<K,V> e = old;
            old = old.next;

            int index = (e.hash & 0x7FFFFFFF) % newCapacity;
            e.next = (Entry<K,V>)newMap[index];
            newMap[index] = e;
        }
    }
}

2.1.7是否线程安全

是．在方法上使用synchronized实现同步．

2.1.8是否接受null值

key和value都不能为null值

2.2 WeakHashMap

跳转目录

2.2.1 继承体系

public class WeakHashMap<K,V>
    extends AbstractMap<K,V>
    implements Map<K,V>

2.2.2 私有属性

//默认初始容量
 private static final int DEFAULT_INITIAL_CAPACITY = 16;
 //最大容量
 private static final int MAXIMUM_CAPACITY = 1 << 30;
 //负载因子
 private static final float DEFAULT_LOAD_FACTOR = 0.75f;
 //存放数据的数组，类型为 Entry<K,V>[]
 Entry<K,V>[] table;
 //元素数量
 private int size;
 //扩容阀值，threshold　＝　capacity * load factor
 private int threshold;
 //负载因子
 private final float loadFactor;
 //保存被gc回收的队列
 private final ReferenceQueue<Object> queue = new ReferenceQueue<>();
 //修改次数计数器，用于检测迭代过程中是否被修改
 int modCount;

2.2.3 节点类型

可以看出节点是一个单链表的结构．
每次创建节点都会把节点的key进行弱引用．

private static class Entry<K,V> extends WeakReference<Object> implements Map.Entry<K,V> {
        V value;
        final int hash;
        Entry<K,V> next;

        Entry(Object key, V value,
              ReferenceQueue<Object> queue,
              int hash, Entry<K,V> next) {
            super(key, queue);
            this.value = value;
            this.hash  = hash;
            this.next  = next;
        }
}

2.3.4 数据结构

哈希表，使用链地址法解决哈希冲突．

2.3.5实现原理

WeakHashMap的key是“弱键”，即是WeakReference类型的。ReferenceQueue是一个队列，它会保存被GC回收的“弱键”。实现步骤是：

１．新建WeakHashMap，将“键值对”添加到WeakHashMap中。实际上，WeakHashMap是通过数组table保存Entry(键值对)；每一个Entry实际上是一个单向链表，即Entry是键值对链表．

２．当某“弱键”不再被其它对象引用，并被GC回收时。在GC回收该“弱键”时，这个“弱键”也同时会被添加到ReferenceQueue(queue)队列中．

３．当下一次我们需要操作WeakHashMap时，会先同步table和queue。table中保存了全部的键值对，而queue中保存被GC回收的键值对；同步它们，就是删除table中被GC回收的键值对．

例子说明

public class WeakHashMapDemo {

    public  static  void main(String[] args){

        Object obj = new Object();

        WeakHashMap  weakHashMap = new WeakHashMap();
        weakHashMap.put(obj,123);
        //将obj去除强引用
        obj =  null;
        //通知gc进行垃圾回收
        System.gc();

        Iterator it = weakHashMap.entrySet().iterator();
        while(it.hasNext()){
            Map.Entry en = (Map.Entry) it.next();
            System.out.println("weakMap:" + en.getKey() + ": " + en.getValue());
        }
    }
}

１．当存在obj = null;时，weakHashMap中的obj对象没有了强引用，当进行gc回收后，weakHashMap中的obj对象即被回收，所以不会打印任何东西．
2．当注释掉obj = null;时，weakHashMap中的obj对象仍然存在强引用，当进行gc回收后，weakHashMap中的obj对象不会被回收，所以会打印以下内容．

weakMap:java.lang.Object@4c75cab9: 123

2.3.6 哈希值和索引值计算

//消除key为null时的影响
private static Object maskNull(Object key) {
    return (key == null) ? NULL_KEY : key;
}
//计算哈希值
final int hash(Object k) {
   int h = k.hashCode();
    h ^= (h >>> 20) ^ (h >>> 12);
    return h ^ (h >>> 7) ^ (h >>> 4);
}
//通过哈希值计算索引值
private static int indexFor(int h, int length) {
     return h & (length-1);
 }

2.3.7 同步quere和table表的数据

当下一次我们需要操作WeakHashMap时，会先同步table和queue。table中保存了全部的键值对，而queue中保存被GC回收的键值对；同步它们，就是删除table中被GC回收的键值对．

private void expungeStaleEntries() {
    for (Object x; (x = queue.poll()) != null; ) {
        synchronized (queue) {
            @SuppressWarnings("unchecked")
                Entry<K,V> e = (Entry<K,V>) x;
            int i = indexFor(e.hash, table.length);

            Entry<K,V> prev = table[i];
            Entry<K,V> p = prev;
            while (p != null) {
                Entry<K,V> next = p.next;
                if (p == e) {
                    if (prev == e)
                        table[i] = next;
                    else
                        prev.next = next;
                    // Must not null out e.next;
                    // stale entries may be in use by a HashIterator
                    e.value = null; // Help GC
                    size--;
                    break;
                }
                prev = p;
                p = next;
            }
        }
    }
}

2.3.8 扩容处理

进行的是两倍扩容

//put方法调用
 resize(tab.length * 2);

2.3.9 是否接受null值

WeakHashMap对key为null的情况进行了处理，WeakHashMap可以接受key和ｖalue为null.但是只能存在一个key为null.

//消除key为null时的影响
private static Object maskNull(Object key) {
    return (key == null) ? NULL_KEY : key;
}

2.3.10 是否是线程安全的

非线程安全．

皮蛋瘦肉
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java 高并发编程详解 9.0 Future(凭据)模式
fenggfa的博客
09-20 163
future模式 异步执行任务
Java9 集合
God_Of_Gun的博客
09-29 246
集合 目录： 集合概念 Collection接口 List接口与实现类 泛型和工具类 set接口与实现类 Map接口与实现类 概念： 对象的容器，定义了对多个对象进行操作的常用方法。可实现数组的功能 和数组的区别： 数组长度固定，集合长度不固定 数组可以存储基本类型和引用类型，集合只能存储引用类型 位置:java.util.* Collection体系集合 包括List和Set List包括ArrayList、LinkedList、Vector Set包括HashSet、SortedSet（Tree
为什么开发者对Java 9如此的兴奋
ifeves的博客
09-16 131
随着标准Java的版本更新，开发者总是可以从升级后的版本中获取想要的功能。那么Java 9的发布为什么会让开发者如此的兴奋？下面列出了一些主要原因：1、模块化的源代码JD...
java9.0——抽象类和接口
weixin_63056061的博客
05-05 263
目录 一，抽象类 1.什么是抽象类 2.抽象类语法 3.抽象类作用 二，接口 1.什么是接口 2.语法规则 3.接口的使用 4.接口的特性 5.接口有什么用？ 6.抽象类和接口的区别 一，抽象类 1.什么是抽象类 一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类 没有实际工作的方法, 我们可以把它设计成一个 抽象方法, 包含抽象方法的类我们称为 抽象类 2.抽象类语法 // 抽象类：被abstract修饰的类 public abstract
java kit 9_jdk9.0官方下载-Java SE Development Kit 9.0官方版下载 -下载啦
weixin_39782394的博客
02-26 723
Java SE Development Kit 9.0简称jdk9.0，这是针对开发者打造的java必备组件，包含了Java运行环境，一堆Java工具和Java基础的类库，这个版本带来了150 项新功能特性，包括备受期待的模块化系统、可交互的 REPL 工具 jshell，以及安全增强、扩展提升等，有需要的欢迎下载。主要特色1、提供了超过 150 项新功能特性2、备受期待的模块化系统、可交互的 R...
UC浏览器JAVA9.0版证书
03-02
UC浏览器JAVA9.0版证书，诺基亚、索尼爱立信等非智能机使用。
Java.9.0.to.17.0.Cookbook
02-25
Java.9.0.to.17.0.Cookbook java9 Cookbook java10 Cookbook java11 Cookbook java12 Cookbook java13 Cookbook java14 Cookbook java15 Cookbook java16 Cookbook java17 Cookbook
uc9.0java通用版
07-03
uc9.0java通用版【界面优化】界面和设置项的样式和布局调整，优化视觉效果，提升操作体验 【功能优化】支持自定义背景色、快捷键，优化翻页、自由复制等功能 【无痕浏览】开启无痕浏览模式后，将不记录网址输入、...
图解Java开发工具JBuilder9.0.pdf
11-18
图解Java开发工具JBuilder9.0.pdf
Java面试宝典9.0.pdf
09-17
Java面试宝典9.0.pdf
JDK9.0的安装包下载
12-20
jdk9的安装文件下载
java jdk 检测安装_Java JDK9.0安装配置检测说明，非常详细
weixin_42517044的博客
02-19 845
Java JDK安装完成需要进行配置，然后进行检测，确认无误之后才能正常使用，为了帮助第一次接触JDK的小伙伴们更快入门，本文就以Java JDK9.0为例，演示软件安装、配置、检测这一系列流程，请看具体说明。如何在Windows系统中安装配置java jdk9.0？安装Java JDK下载Java JDK，解压压缩包，双击.exe文件，弹出界面，根据向导操作，点击【更改】，设置软件保存路径，你也...
java中的双端队列deque使用以及部分原理
胖墩的IT博客
03-22 2670
转载自：https://www.cnblogs.com/denglh/p/7911513.html package collections; import java.util.Deque; import java.util.LinkedList; /** * @Package collections * @date 2017-11-28下午5:53:32 */ public class ...
Java 9 与 Java 10
找到了最重要的事情
04-10 3193
现在java发展到目前的阶段应该算是非常成功的，自java 9 之后oracle采用新的更新的策略，即每半年发布一个新版本，也就是用不了多久java 11 , 12会接踵而至。 java 9是一个坎，引入了jagsaw模块化技术，以及版本号的变化变 9.0.x有大量的软件需要更新才能适配 java 9。当然对应的开发工具也需要更新，比如eclipse之类的。 新的环境变量设置方式： 因为模块...
知了堂Java V9.0重磅升级，真的很硬核！
qq_35254085的博客
06-16 176
从Chat gpt的兴起，到今年不同厂商的AI大模型入侵各行各业，AI应用与大部分人的职业捆绑越发紧密，尤其对程序员的工作影响巨大，这意味着当前的Java工程师正在面临一项新挑战，形势之下，作为一家职培教育企业，知了堂也必须“更新迭代”。8.0版更专注于开发本身，重点培养开发实战，但随着当前企业对人才的要求逐渐由单一转向多维，需要掌握的技能越来越多，V9.0版升级课程正好接力，以企业用人需求为导向，增加多元化的课程体系，丰富学员的技术维度。相比之下，课程难度升级，更匹配于当下的技术流行需求。
如何用java9.0_教大家如何在Windows系统中安装配置java jdk9.0
weixin_42601702的博客
02-27 323
近日有关于如何在Windows系统中安装配置java jdk9.0的问题受到了很多网友们的关注，大多数网友都想要知道如何在Windows系统中安装配置java jdk9.0的具体情况，那么关于到如何在Windows系统中安装配置java jdk9.0的相关信息，小编也是在网上进行了一系列的信息，那么接下来就由小编来给大家分享下小编所收集到与如何在Windows系统中安装配置java jdk9.0相...
java9.0.4安装视频_WIN10 Java9安装
weixin_33362096的博客
02-23 83
输入javac后显示：C:\Users\LOLI>javac用法: javac 其中, 可能的选项包括:@ 从文件读取选项和文件名-Akey[=value] 传递给注释处理程序的选项--add-modules (,)*除了初始模块之外要解析的根模块; 如果 为 ALL-MODULE-PATH, 则为模块路径中的所有模块。--b...
Java 9 模块化系统详解
BXA
06-01 3406
Java在发展过程中逐渐变得庞大而复杂，Java应用程序的规模逐渐变大，尤其是企业级应用代码结构臃肿不断添加自定义库或第三方依赖，这样会导致潜在的问题，例如包访问冲突和兼容性影响等。因此Java SE 9 引入了一种新的模块化系统来解决这些问题。在 Java 模块中模块描述符表示了模块对其他模块的依赖、导出等信息，它是指定用于组合和部署模块化应用程序的元数据文件。有关模块中描述符的细节介绍可以参考下面的代码示例模块描述符由一系列语句和指令组成，以空格、制表符、换行符作为分隔符进行书写。
java9.0.4配置_Tomcat 9.0 安装配置
weixin_36418862的博客
02-26 218
本文转自:http://blog.sina.com.cn/s/blog_15126e2170102w5o8.html一、JDK的安装与配置1、从官网下载jdk，注意是jdk不是jre。最好从官网下载，也可以直接度娘。2、下载完毕后，安装jdk，​直接按照安装向导的提示安装即可，安装时可以自己选择安装路径，我的安装路径是C:\Program Files\Java\jdk1.8.0_313、配置环境变...
PowerBuilder9.0常用函数记录
最新发布
03-01
PowerBuilder9.0常用的一些函数，资源备份防止丢失。 包括函数用途和使用方法。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值