Java集合（偏向结构解析）

前言：这是我在面试的时候发现面试官很喜欢考Java集合底层结构，故而总结的，至此我的秋招仍没有结束，只是将我理解的知识写上去，许多地方阅读可能有小问题。只能等招聘结束再修改了。

 

 

Java集合

fail-fast 机制是java集合(Collection)中的一种错误机制。当多个线程对同一个集合的内容进行操作时，就可能会产生fail-fast事件。例如：当某一个线程A通过iterator去遍历某集合的过程中，若该集合的内容被其他线程所改变了；那么线程A访问集合时，就会抛出ConcurrentModificationException异常，产生fail-fast事件。

 

数组和集合的区别:

 

 

Java集合按照存储结构可以分为两大类,即单列集合Collection和双列集合Map

1) 数组长度固定

集合长度可变

2) 内容的区别

数组只能存储一种类型的元素

集合,可以存储多种元素

3) 数组可以存储引用类型,也可以存储基本类型

集合:只能存储引用类型(若有基本类型,将基本类型变成包装类)

 

Collection单列集合类的根接口,其中有两个重要子接口List和Set.

List接口的主要接口有ArrayList和LinkList Vector

Set接口的主要类有HashMap和TreeMap 以及 LinkedHashSet

 

 

Map双列集合的主要实现类哟HashMap和TreeMap;

 

List和Set的区别

1.set接口实例存储是无序的,不重复的数据,List接口实现存储是有序的,可以重复的元素.

2.set检索效率idxia(因为检索依靠Hash值,需要进行计算),删除和插入效率高(因为插入和删除的时候其他元素的位置不会发生变化),删除和插入如并不会引起元素位置的改变,实现类有HashSet和TreeSeti以及LinkHashSet

3.List和数组lsi,可以动态增长,根据实际存储的数据长度自增长List的长度.查找元素效率高(依靠下标查询).插入删除效率低(因为插入的时候其他位置的下标和数组整个长度会变化),因为会引起其他元素位置的改变,实现类有ArrayList,LinkedLIst,Vector

--------------------- 本文来自 Sanoy 的CSDN 博客 ，全文地址请点击：https://blog.csdn.net/IT_PL/article/details/79150046?utm_source=copy

总结:1 .set存储无序无重复,LIst有序有重复

2.set检索按,List检索块

3.set插入如和删除快,因为并不会影响原有元素位置的改变,List插入和删除慢,会引起其他位置的变化.

 

List集合子类的特点:

 ArrayList(面试题中没有告诉具体的集合:默认都使用ArrayList)

内部是一种数组实现,查询快,增删慢

线程不安全,--à不同步-à执行效率高

      

Vector:底层是一种数组实现,查询快,增删慢

线程安全的类,同步-à执行效率低

StringBuffer:线程安全的类

 

LinkedList:底层是一种链接列表实现,查询慢,增删快,

线程不安全,不同步-à执行效率高

 

 

ArrayList和和LinkedList区别:

1 : ListkedList 插入删除快 (是链表结构,因为插入删除的时候只需要功能上下两个元素的索引,即可)

而ArrayList是连续存储,插入删除会引起整个数组的改变,和下标索引的改变.

 

2 :查询的是ArrayList比较快,因为依据下标索引即可查询到相应的元素,而LinkedList需要一个额往后查询,因为上一个元素的最后就是下一个元素的索引.

3.结构不同,ArrayList是基于数组的动态的数据结构,而LinkedList是基于链表的结构.

 

ArrayList和Vector区别

 

相同点:都是基于索引,内部结构是数组 ,两者元素存取都允许null

不同点: 1 Vector是安全,效率慢 ,对应的LIst是不安全的,效率高

2.初始容量都是10,ArrayList都是默认增长百分之五十,(Vector增长一倍.可以设置的)

3.ArrayList更通用.

 

 

Set集合:  Set集合的元素不重复,能保证唯一性(不能保证元素的迭代的顺序恒久不变)

HashSet存放元素的过程：获取元素的hashCode()值，再通过散列(hash)算法找到要存放的位置；一般我们在定义类时，重写equals()方法也要重写hashCode()方法，要保证两个对象equals()返回值为true时，它们的hashCode()返回值也相同；但是有时候会出现以下两种情况，那元素是如何存储的呢？

1：两个对象通过equals()返回值为true，但这两个对象的hashCode()返回值不同时，会导致HashSet将这两个对象存放在不同的位置，但是这和HashSet的不可重复规则冲突；

2：两个对象通过equals()返回值为false，但这两个对象的hashCode()返回值相同，因为两个对象的hashCode()返回值一样，所以HashSet将试图把它们保存在同一个位置，但是一个位置不允许存放两个元素，所以在这个位置用链表来保存多个元素

因为它们添加元素调用的是Map的put方法，说明存储结构和map类似

HashSet   TreeSet(主要条件 :对自定义的属性进行规制排序)

HashSet:   -àhashtable:哈希表 --à依赖于两个方法 HashCode()哈希码值   equals()方法

如果使用HashSet集合存储自定义对象并遍历(如果自定义对象的成员变量的值一样,把它同一个对象):在类中重写上面两个方法

           

 LinkedHashSet:保证元素唯一性(哈希表)添加了双列链表保证添加的顺序性

                           保证元素的有序性(存储和取出一致):由链接列表保证

 

TreeSet:基于TreeMap的红黑树结构(内部是一种自平衡的二叉树结构…)

存储方法依赖于TreeMap

底层源码:有两种排序(根据构造方式不一样)

TreeSet() ;   自然排序 自定义的类,必须实现Comparable接口,重写里面的compareTo(Object O)方法

TreeSet(Comparator<T>  comparator):比较器排序:  采用匿名内部类的方式进行排序(主要条件)

 

 

疑问:为何LinkedHashSet能保证元素唯一性,和元素有序性,这两者如何不矛盾,

因为它们存储也是依靠hashCode值,但是地址值存在链表中,该链表是以存取顺序存放的.

HashSet和TreeSet

1.HashSet不能保证元素的排列顺序,TreeSet是SortedSet接口的唯一实现类,可以确保集合元素处于元素处于排序状态.

2.HashSet底层用的是哈希表,TreeSet用的结构是红黑树.

3.HashSet中元素可以是null,TreeSet不允许NULL

 

HashSet和LinkedHashSet区别:

1.HashSet不能保证存取一致性,Linked...可以.

2.前者查询慢,但是插入删除快

 

 

Map-----

TreeMap HashMap LinkedHashMap

相同点: 1都是接口

关系:HashSet依赖于HashMap

treeset 依赖于treeMap

集合中collection和Map集合的区别:

1.map是一种键和值的映射关系,是种双列集合 Collection是单列集合,只能存储一种类型元素

Map<K,V>:是双列集合,里面 元素一一映射(Mapping)的关系     框架部分:映射文件(在xml配置一些实体类的信息)

一个键对应一个值

Map集合只针对键有效,键唯一的,如果重复,那么后面键对应的值

会将前面键对应的值覆盖掉,返回的是前面的键对应的值

子实现类:HashMap<K,V>

Map<k,V> map = new HashMap<k,v>();

Map集合遍历的方式:

1) 通过keySet()获取所有的键的集合 :这种方式使用最多

2) 通过获取键值对对象entrySet() ;

 

子实现类有HashMap TreeMap HashTable

 

实现:

HashMap基于

 

LinkedHashMap 基于哈希表和.链表实现,能够保证键的唯一性并且元素有序.

TreeMap能够实现排序.基于红黑树

 

 

HashMap应该每个面试官必问的类了，务必完全掌握

HashMap工作原理---------

结构:是以拉链法来存储的,就是以数组+链表形式存储.

基于哈希原理,通过put和get方法存储和获取元素,put方法是通过Hashcode()计算出值,找到对应的bucket位置来存储数据,当HashCode值相同的时候,再进行判断键对象是否相同,如果相同,则只更新value值,如果只是hashcode相同,则存储在该bucket位置链表的下一个节点.获取put方法是算出hashcode,找到bucket位置,然后遍历链表,通过key的equals方法,找到键值对

H

好处:作为缓存十分方便,能间接实现数据库的功能 ,实现一些简单的编号对应数据的存储 (例如扑克牌).

有HashMap和HashTable是子实现类:

相同:都是基于hash实现的,每个元素都是Key-value的键值对,内部通过单向链表解决冲突,容量都会自动增长

区别:1.父类不同HashMap父类是AbstractMap类,而HashTable是Dictionary类

2.线程同步,和不同步 安全和不安全,效率高低

3.HashTable初始容量是11,扩容是增加一倍加1 HashMap key 初始容量是16扩容方式是增加一倍

4.是否有contains方法,HashMap中将Contains变为Containkey和Containvalue方法,而Hashtable中有全部三个方法,而contains和containvalue效果相同

5.内部遍历的方式不同,现在都是用Iterator的遍历,但是之前HashTable还用过Enumeration方式

6..HashMap key 和value允许null值,而HashTable则不允许.

7.Hash值不同,HashTable是使用HashCode方法获取Hash值,而HashMap是重新计算Hash值(重新Hash(key.HashCode())) // 根据key的keyCode重新计算hash值。 7 int hash = hash(key.hashCode());

 

 

 

HashMap存储过程深度讲解：

对于HashMap及其子类而言，它们采用Hash算法来决定集合中存储元素的存储位置。当系统开始初始化HashMap时，系统会创建一个长度为capacity的Entry数组，这个数组可以存储元素的位置称为“桶”（bucket），每个bucket都有其指定索引，系统可以根据其索引快速访问该bucket里存储的元素。

无论何时，HashMap的每个“桶之存储一个元素”（也就是一个Entry），由于Entry对象可以包含一个引用变量（就是Entry构造器的最后一个参数，用于指向下一个Entry），因此可能出现的情况是：HashMap的bucket中只有一个Entry，但是这个Entry指向另一个Entry ----这就形成了一个Entry链，图解

 

 

 

 

 

 

困惑：那么它们是如何读取数据的，它们既然是通过数组存储，但是hash值明显不是按顺序的，这样存储，不符合数组存储规则：

解答：它们并不是一个一个按顺序存的，而是一开始就创建好了一个有一定长度的数组，这时候，我们会根据hash值（hash(key.hashcode())）去存储元素。

那它们是如何读取数据的呢：

如果两个键的Hash值相同，你如何获取值对象？

计算键的Hash值，找到相应bucket位置，遍历链表，调用keys.equals（）方法去找到LinkedList中正确的将，最终找到要存的值。

如果HashMap的大小从了负载因子定义的容量，怎么办？

这道题就需要我们真正知道HashMap的工作原理，否则你将回答不出这道题。默认的负载银子大小是0.75，也就是说，当一个map填满了百分之75的bucket的时候，和其他集合类（如ArrayList等一样），将会创建原来HashMap大小的两倍bucket数组，来重新调整map的大小，并将原来的对象放入buckey数组这个。这个过程叫做rehashing，因为它调用hash方法找到信息的bucket位置，遍历出队尾

 

你了解重新调整HashMap大小存在什么问题吗？（扩容重哈希的时候容易死循环，脏读等）

 

在多线程中，可能产生条件竞争，当重新调整HashMap大小的是，确实存在条件竞争，因为两个线程都发现了HashMap需要重新调整大小了，它们会同时试着调整大小了。在调整大小的过程中，存储在LinkedLIst元素次序会反过来，因为移动到新的bucket位置的时候，HashMap并不会将元素放在LinkedList的尾部，而是放在头部，这是为了避免尾部遍历（每次遍历链表，找到尾部位置）。如果条件竞争发生了，那么久会死循环了。这个时候，质问面试官，太奇怪了，为什么不再多线程环境用ConcurrentHashMap。

 

为什么String, Interger这样的wrapper类适合作为键？ 

 

因为这些类都是不可变类，都已经重写了hashcode()方法和equals方法，表示他们是不可变的，不可变在多线程中意味着键值不会被改变，说明这是安全的，在

可以用自定义对象作为键吗

可以的，可以使用任何对象作为键，只要它遵守equals方法和 Hashcode方法的定义规则，当对象插入到HashMap之后就不会再改变了。如果这个自定义对象不可改变时，说明该对象已经满足了作为键的要求。

HashTable使用get方法加锁

ConcurrentHashMap

ConcurrentHashMap和HashMap思路上是差不多的，但是因为它支持并发操作，所以要复杂一些。

整个ConcurrentHashMap由一个个segment组成，Segment代表“部分”或者“一段”的意思，所以很多地方都会将其描述为分段锁。注意，很多“槽”代表一个segment

 

 

简单的理解就是，ConcurrentHashMap是一个Segment数组，Segment通过集成ReentrantLock来进行枷锁，所以每次需要加锁的操作锁住的是一个Segment,这样只要保证每个Segment是线程安全的，也就实现了全局的线程安全。

有16个Segment,所以理论上，这个时候，最多可以同时指出i16个线程并发,只要它们的操作分别分布在不同的Segment上。这个值可以在初始化的时候设置其他值，但是一旦初始化以后，它是不可以扩容的。

再具体到每个Segment内部，其实每个Segment很想之前介绍的HashMap，不过它要保证线程安全，所以处理起来要麻烦一些

 

初始化：

初始容量是指整个ConcurrentHashMap的初始容量，实际操作的时候需要平均分给每个Segment

 

负载因子是给每个Segment内部使用的

 

特点总结：（在HashTable性能太差的情况下，推出了既安全又快捷的ConcurrentHashMap）

 

Segment数组长度为16，不可以扩容

Segment[i]的默认大小为2，负载因子是0.75，得出初始阈值为1.5，

也就是以后插入第一个元素不会触发扩容，插入第二个元素会触发扩容。

 

 

Put操作：

由于put方法需要对共享变量进行写入操作，所以为了线程安全，在操作共享变量的时候必须得加锁。Put方法首先定位到Segment，然后再Segment里进行插入操作。插入操作经历两个步骤，第一判断是否需要对Segment里面的Entry数组进行扩容，第二步定位添加元素的位置，然后放在HashEntry数组里。

根据key的hash值的高n位就可以确定元素到底在哪一个Segment中。

其他操作和HashMap无区别。

 

效率的提高是因为：

HashTable本身是线程安全的，但是通过Syncharonized关键字实现线程安全，这样对整张表实现同步的缺陷就在于使效率很低。ConcurrentMap将锁加在Segment，这样我们在对Segment1操作的时候，同时也可以对Segment2中的数据进行操作，这样的效率就会高很多。

 

 

LinkedHashMap

概述：因为HashMap是无序的，也就是说，迭代HashMap所得到的元素并不是最初放的顺序。所以我们需要一个保持插入顺序的Map。庆幸的是，JDK为我们解决了这个问题，为HashMap提供了一个子类-----LinkHashMap(保持插入和访问顺序）

 

在这之间我们必须复习一下链表的相关知识：

单链表和双链表的区别：

单链表只有一个指向下一节点的指针，也是说只能next.

双链表除了有一个指向下一节点的指针外，还有一个指向前一节点的指针，可以通过prec()快速找到前一节点，单链表只能单向读取，双链表能够双向读取

 

为什么市面上用单链表更多：虽然双链表在查找，删除的时候可以用二分法实现，效率更高，但是因为单链表使用的空间小，实际上上是用时间换空间，在效率要求不高的情况下经量使用单链表，

 

LinkedHashMap实现了Map接口，继承于HashMap,于HashMap不同的是，它维持有一个双链表，从而可以保证迭代时候的顺序，不同的是HashMap维持的是单向链表

 

 

 

 

 

 

 

 

TreeMap:

 

红黑树是一种近似平衡的二叉查找树，它能够保证任何一个的节点的左右子树高度差不会超过二者中较低的那个的一倍。具体来说，共黑数是满足如下条件的二叉查找树：

1.每个节点要么是红色，要么是黑色。

2.根节点必须是黑色

3.红色节点不能连续，（也即是，红色节点的孩子和父亲都不能是红色）。

4.对于每个节点，从该点至null(树尾端)的任何路径，都含有相同个数的黑色节点

 

在树的结构发生改变时，往往会破坏上述条件3或条件4，需要通过调整使得查找树重新满足红黑树的条件。

 

总结：程序添加新节点的时候，总是从数的根节点开始比较，即将根节点当成当前节点。如果新增节点大于当前节点并且当前节点的右节点存在，则以右节点为当前节点。若是新增节点比当前节点小，并且左节点存在，则当前节点为做节点；若新增节点等于当前节点，则用新增界定啊覆盖当前节点，并结束循环 。否则，知道某个节点的左右节点不存在，将新节点添加为该节点的子节点。如果新节点比该节点大，则添加为右子节点内，反之也可。