关于java中的容器、集合（Array、List、Map、Set......）

肆〇

已于 2022-05-24 19:11:28 修改

阅读量1.7k

点赞数 3

分类专栏：后端 java 集合文章标签： java list 数据结构 1024程序员节后端

于 2021-10-03 18:07:19 首次发布

本文链接：https://blog.csdn.net/m0_51660523/article/details/120596475

版权

java 同时被 3 个专栏收录

37 篇文章 3 订阅

订阅专栏

后端

31 篇文章 4 订阅

订阅专栏

集合

3 篇文章 0 订阅

订阅专栏

collection接口通常情况下不被直接使用，Java中的集合类分为4大类，分别由4个接口来代表：

接口	特点	父类
Set	无序的、元素不可重复的集合	Collection
List	有序的、元素可以重复的集合
Queue	先进先出（FIFO）的队列
Map	具有映射关系（key-value）的集合

上面所说的集合类的接口或实现，都位于java.util包下，这些实现大多数都是非线程安全的。虽然非线程安全，但是这些类的性能较好。如果需要使用线程安全的集合类，则可以利用Collections工具类，该工具类提供的synchronizedXxx()方法，可以将这些集合类包装成线程安全的集合类。

java.util包下的集合类中，也有少数的线程安全的集合类，例如Vector、Hashtable，它们都是非常古老的API。虽然它们是线程安全的，但是性能很差，已经不推荐使用了。

从Java 5开始，Java在java.util.concurrent（JUC）包下提供了一批支持高效并发的集合类，这些类既实现了线程安全，又保证了可靠的性能。这些集合类按照名字可以分为两大类，它们分别以Concurrent开头或CopyOnWrite开头。

以Concurrent开头的集合类，在多线程读取数据时则没有加锁，以提高读取的性能。在多线程写入数据时加锁，来保证所有写入操作是线程安全的。这些类都采取了比较复杂的算法，在加锁时不会锁住整个集合，从而保证并发写入时具有更好的性能。

以CopyOnWrite开头的集合类，采用写时复制技术来实现并发写操作，它复制的是底层的数组。当线程读取集合中的数据时，它直接读取集合本身的数据，不会加锁。当线程向集合写入数据时，该集合会在底层复制一份新的数组，然后对这个新数组执行写入操作。由于所有写入操作都是对数组的副本的操作，所以它是线程安全的。

java.util包下常用的集合类，及其继承关系如下图所示：

如图，Java提供了众多集合的实现类，它们都是这些接口的直接或间接的实现类，其中比较常用的有：HashSet、TreeSet、ArrayList、LinkedList、ArrayDeque、HashMap、TreeMap等。

顺序表：

1、Array
Array是一段连续的存储结构：

数据结构：

array其实记录的是数组的首地址，而array[1]其实相当于在i的地址的基础上加上1个整数的地址偏移，然后再取这块地址中的值。

新建数组Array：

int[] array = new int[3]

Array数组可以包含基本类型和对象类型，但是数组中存放的元素一定是同种类型的元素。

数组必须要在初始化时分配固定的大小，比如说int[] a=new int[3];如果我们仅仅写int[] a=new int[];编译器就会无情地给我们报错。但是List由于空间不必连续，所以无须指定初始大小。

Array 数组长度不可变，一旦生成就不能改变其长度，所以在此基础上有了List。

List:

List是不连续的存储结构,List的每个节点都有着一个Next属性，这个属性则记录着他的下一个节点的地址。也就是说当我们想找第100个节点的时候，他还是需要从第一个节点，然后做99次Next操作，才能找到list[99]节点。List可以自动扩容。

List是一个接口，List的两个重要接口，ArrayList和LinkedList都是实现了List接口的类：

ArrayList的继承实现关系图：

关于ArrayList动态扩容机制：

ArrayList list = new ArrayList(20);中的list扩充0次：

初始化：有三种方式

1. 默认的构造器，将会以默认的大小来初始化内部的数组：

public ArrayList();

2. 用一个ICollection对象来构造，并将该集合的元素添加到ArrayList：

  public ArrayList(Collection<? extends E> c)

3. 用指定的大小来初始化内部的数组：

 public ArrayList(int initialCapacity)

这里我们来重点关注一下无参数构造器的实现过程：

通过源码可知它的初始容量为0。而在之前JDK1,6中，初始容量为10。
发生扩容的条件：根据传入的最小需要容量minCapacity来和数组的容量长度对比，若minCapactity大于或等于数组容量，则需要进行扩容。（如果实际存储数组是空数组，则最小需要容量就是默认容量）

实现扩容：jdk7中采用>>位运算，右移动一位。容量相当于扩大了1.5倍；

举例说明：添加20个元素到ArrayList中

当第一次插入元素时才分配10（默认）个对象空间。之后扩容会按照1.5倍增长。

也就是当添加第11个数据的时候，Arraylist继续扩容变为10*1.5=15；

当添加第16个数据时，继续扩容变为15 * 1.5 =22个；

总结：在JDK1.7中，如果通过无参构造的话，初始数组容量为0，当真正对数组进行添加时，才真正分配容量。每次按照1.5倍（位运算）的比率。

ArrayList却只能包含对象类型。 ArrayList就不一定了，因为ArrayList可以存储Object。

ArrayList的访问速度比LinkedList快，适合大量的访问操作，而LinkedList则适用于频繁的中间插入和删除操作，且可以当做Queue队列使用。ArrayList线程安全？允许存放重复对象。

LinkedList的继承实现关系图：

如果需要经常对数据进行插入和删除操作，LinkedList最适合。

LinkedList类中对首元素和尾元素的一些操作方法是特有的，在ArrayList中没有，如removeFirst()、removeLast()...这正是LinkedList的一大优势。

总结：

如果想要保存一些在整个程序运行期间都会存在而且不变的数据，我们可以将它们放进一个全局数组里，但是如果我们单纯只是想要以数组的形式保存数据，而不对数据进行增加等操作，只是方便我们进行查找的话，那么，我们就选择ArrayList。而且还有一个地方是必须知道的，就是如果我们需要对元素进行频繁的移动或删除，或者是处理的是超大量的数据，那么，使用ArrayList就真的不是一个好的选择，因为它的效率很低，使用数组进行这样的动作就很麻烦，那么，我们可以考虑选择LinkedList。

JAVA中List与Array之间互相转换

1. 将list转换为array：列表类型.toArray();

2. 将array转换为list：Arrays.asList(数组类型);

3. 将array转换为String：Arrays.toString(数组类型)

List 转 Array

public class ListToArray {

    public static void main(String[] args) {
        //新建一个List列表
        ArrayList<String> list1 = new ArrayList<String>();
        list1.add("list1");
        list1.add("list2");
        list1.add("list3");
        list1.add("list4");
        list1.add("list5");
        //执行list转换为array方法
        System.out.println(Arrays.toString(listToArray(list1)));
    }

    public static Object[] listToArray(ArrayList list) {
        Object[] array1 = new String[list.size()];
        array1 = list.toArray();
        return array1;
    }
}

最好用 new 的方式构建，因为 list.toArray() 默认转换为 Object[] 对象。
Array 转 List

public class ArrayToList {

    public static void main(String[] args) {
        //新建一个Array数组
        String[] array2 = new String[]{"s1","s2","s3","s4","s5"};
        //执行array转换为list方法
        System.out.println(arrayToList(array2));
    }

    public static List<String> arrayToList(String[] strings) {
        List<String> list2= Arrays.asList(strings);
        return list2;
    }
}

Linkedlist与ArrayList转换：


//ArrayList与类LinkedList不能强制数据类型转换。

//1.通过构造方法转换
ArrayList arrayList1 = new ArrayList();
LinkedList linkedList1 = new LinkedList(arrayList1);

LinkedList linkedList2 = new LinkedList();
ArrayList arrayList2 = new ArrayList(linkedList2);
 

//2.通过list的add方法

Set

set集合容器内部是用二叉搜索树实现的，容器内每一个元素只会出现一次，并且是排好序的，复杂度只有 O(log2n)，非常高效。

AbstractSet继承自Set。

HashSet继承自AbstractSet

WeakMap继承自Set

List、Map、Set三个接口存取元素时，各有什么特点？

答：List以特定索引来存取元素，可以有重复元素。Set不能存放重复元素（用对象的equals()方法来区分元素是否重复）。Map保存键值对（key-value pair）映射，映射关系可以是一对一或多对一。Set和Map容器都有基于哈希存储和排序树的两种实现版本，基于哈希存储的版本理论存取时间复杂度为O(1)，而基于排序树版本的实现在插入或删除元素时会按照元素或元素的键（key）构成排序树从而达到排序和去重的效果。

hashmap：

下面哪个是排序的？

LinkedHashMap、HeatSet、TreeSet√、AbstractSet

Map

Map集合概述和特点

概述：
java中的映射集合（Map）是将键映射到值的对象，一个映射不能包含重复的键，每个键最多只能映射到一个值，key不可以重复，但是value可以重复。
Map接口和Collection接口的不同：

	Map	Collection
存储结构	双列	单列
键	唯一	子体系Set是唯一的
数据结构	对键有效，跟值无关	针对元素有效

Map集合的常用功能：

功能	语句	描述
添加	V put(K key,V value)	添加元素,这个其实还有另一个功能?替换如果键是第一次存储，就直接存储元素，返回null 如果键不是第一次存在，就用值把以前的值替换掉，返回以前的值
删除	void clear()	移除所有的键值对元素
删除	V remove(Object key)	根据键删除键值对元素，并把值返回
c:判断功能	boolean containsKey(Object key)	判断集合是否包含指定的键
	boolean containsValue(Object value)	判断集合是否包含指定的值
	boolean isEmpty()	判断集合是否为空
获取	Set<Map.Entry<K,V>> entrySet()	返回一个键值对的Set集合
	V get(Object key)	根据键获取值
	Set keySet()	获取集合中所有键的集合
	Collection values()	获取集合中所有值的集合
e:长度功能	int size()	返回集合中的键值对的对数

通常来说，Map是一个由键值对组成的数据结构，且在集合中每个键是唯一的。下面就以K和V来代表键和值，来说明一下java中关于Map的九大问题。
1、将Map转换为List类型
在java中Map接口提供了三种集合获取方式：Key set，value set，key-value set.。它们都可以通过构造方法或者addAll()方法来转换为List类型。代码如下：

ArrayList：
// key list
List keyList = new ArrayList(map.keySet());
// value list
List valueList = new ArrayList(map.valueSet());
// key-value list
List entryList = new ArrayList(map.entrySet());

1、通过Entry 遍历Map
java中这种以键值对存在的方式被称为Map.Entry。Map.entrySet()返回的是一个key-value 集合，这是一种非常高效的遍历方式。

for(Entry entry: map.entrySet()) {
  // get key
  K key = entry.getKey();
  // get value
  V value = entry.getValue();
}

Iterator 我们也经常用到，尤其是在JDK1.5以前

Iterator itr = map.entrySet().iterator();
while(itr.hasNext()) {
  Entry entry = itr.next();
  // get key
  K key = entry.getKey();
  // get value
  V value = entry.getValue();
}

2、按key来对Map排序
排序需要对Map的key进行频繁的操作，一种方式就是通过比较器(comparator )来实现：

List list = new ArrayList(map.entrySet());
Collections.sort(list, new Comparator() {
  @Override
  public int compare(Entry e1, Entry e2) {
    return e1.getKey().compareTo(e2.getKey());
  }
});

另外一种方法就是通过SortedMap，但必须要实现Comparable接口。


SortedMap sortedMap = new TreeMap(new Comparator() {
 
  @Override
  public int compare(K k1, K k2) {
    return k1.compareTo(k2);
  }
 
});
sortedMap.putAll(map);

3、按value对Map进行排序
这与上一点有些类似，代码如下：

List list = new ArrayList(map.entrySet());
Collections.sort(list, new Comparator() {
 
  @Override
  public int compare(Entry e1, Entry e2) {
    return e1.getValue().compareTo(e2.getValue());
  }
});

4、初始化一个static 的常量Map
创建一个全局静态Map有以下两种方式，而且都是线程安全的。
下面代码，声明了map是静态的，但是在初始化时，我们依然可以改变它的值，比如Test1.map.put(3,"three");

public class Test1 {
 
  private static final Map map;
  static {
    map = new HashMap();
    map.put(1, "one");
    map.put(2, "two");
  }
}

在Test2中，我们通过一个内部类，将其设置为不可修改，那么当我们运行Test2.map.put(3,"three")的时候，它就会抛出一个UnsupportedOperationException 异常来禁止你修改。

public class Test2 {
 
  private static final Map map;
  static {
    Map aMap = new HashMap();
    aMap.put(1, "one");
    aMap.put(2, "two");
    map = Collections.unmodifiableMap(aMap);
  }
}

6、Map中的反向查询
我们在Map添加一个键值对后，意味着这在Map中键和值是一一对应的，一个键就是对应一个值。但是有时候我们需要反向查询，比如通过某一个值来查找它的键，这种数据结构被称为bidirectional map，遗憾的是JDK并没有对其支持。
Apache和Guava 共同提供了这种bidirectional map实现，它在实现中它规定了键和值都是必须是1:1的关系。
7、对Map的复制
java中提供了很多方法都可以实现对一个Map的复制，但是那些方法不见得会时时同步。简单说，就是一个Map发生的变化，而复制的那个依然保持原样。下面是一个比较高效的实现方法：
Map copiedMap = Collections.synchronizedMap(map);
当然还有另外一个方法，那就是克隆。但是我们的java鼻祖Josh Bloch却不推荐这种方式，他曾经在一次访谈中说过关于Map克隆的问题：在很多类中都提供了克隆的方法，因为人们确实需要。但是克隆非常有局限性，而且在很多时候造成了不必要的影响。
8、创建一个空的Map
如果这个map被置为不可用，可以通过以下实现
map = Collections.emptyMap();
相反，我们会用到的时候，就可以直接。

Map接口几个重要的实现类：hashMap、TreeMap、Hashtable、LinkedHashMap。

threadlocalmap使用开放定址法解决haah冲突，hashmap使用链地址法解决hash冲突

TreeMap用到了解决哈希冲突的开放定址法

实现类TreeMap、HashMap可以用于存储键，值对，并且方法调用提供了基本的多线程安全支持：()

1、什么是 HashMap，什么时候选择 HashMap？

说到容器我们会想到 Java中对象存储容器还有ArrayList，LinkedList，HashSet等，HashMap 相对这些容器来说，可以理解为多了一层指向关系，可以用指定Key找到指定Value。

比如现在有一个Java Bean 用于存储职员的信息，字段包括（职员姓名，职员年龄，职员身高，职员体重，职员教育程度 ... 等等），我是一名人力资源管理，我需要将员工信息整理好发给老板。这个时候出现了两个人名字一样的问题，查到的到底是谁的信息呢？前者信息会被覆盖吗？带着问题来学习一下HashMap数据结构及其工作原理。

2、HashMap 数据结构及其工作原理？

2.1 数据结构

HashMap 数据结构为数组+链表，其中：链表的节点存储的是一个 Entry 对象，每个Entry 对象存储四个属性（hash，key，value，next）

整体是一个数组；

数组每个位置是一个链表；
链表每个节点中的Value即我们存储的Object；

2.2 工作原理

首先，初始化 HashMap，提供了有参构造和无参构造，无参构造中，容器默认的数组大小 initialCapacity 为 16，加载因子loadFactor 为0.75。容器的阈(yu)值为 initialCapacity * loadFactor，默认情况下阈值为 16 * 0.75 = 12; 后面会讲到阈值有啥用。

然后，这里我们拿 PUT 方法来做研究：

第一步：通过 HashMap 自己提供的hash 算法算出当前 key 的hash 值

第二步：通过计算出的hash 值去调用 indexFor 方法计算当前对象应该存储在数组的几号位置

第三步：判断size 是否已经达到了当前阈值，如果没有，继续；如果已经达到阈值，则先进行数组扩容，将数组长度扩容为原来的2倍。

注意size 是当前容器中已有 Entry 的数量，不是数组长度。

第四步：将当前对应的 hash，key，value封装成一个 Entry，去数组中查找当前位置有没有元素，如果没有，放在这个位置上；如果此位置上已经存在链表，那么遍历链表，如果链表上某个节点的 key 与当前key 进行 equals 比较后结果为 true，则把原来节点上的value 返回，将当前新的 value替换掉原来的value，如果遍历完链表，没有找到key 与当前 key equals为 true的，就把刚才封装的新的 Entry中next 指向当前链表的始节点，也就是说当前节点现在在链表的第一个位置，简单来说即，先来的往后退。此时已经将当前的 key-value 存储到了容器中。PUT 是操作HashMap的最基础操作，了解了 PUT 的机制后，再去看 API其他方法源码的时候你会有所眉目，可以带着这种初知去探究 HashMap 的其他方法。

扩容机制：

HashMap 使用 “懒扩容” ，只会在 PUT 的时候才进行判断，然后进行扩容。

将数组长度扩容为原来的2 倍
将原来数组中的元素进行重新放到新数组中

需要注意的是，每次扩容之后，都要重新计算原来的 Entry 在新数组中的位置，为什么数组扩容了，Entry 在数组中的位置发生变化了呢？所以我们会想到计算位置的 indexFor 方法，为什么呢，该方法部分源码：

static int indexFor(int h, int length) { // h 为key 的 hash值；length 是数组长度
     return h & (length-1);  
}

由源码得知，元素所在位置是和数组长度是有关系的，既然扩容后数组长度发生了变化，那么元素位置肯定是要发生变化了。HashMap 计算元素位置采用的是 &运算，为什么 HashMap使用这种方式计算在数组中位置呢？

按照我们的潜意识，取模就可以了。hashMap 用与运算主要是提升计算性能。这又带来一个新问题，为什么与运算要用 length -1 呢，回看 hashmap初始化的时候，数组长度 length必须是2的整次幂（如果手动传参数组长度为奇数n，hashMap会自动转换长度为距离n最近的2的整次幂数），只有这样， h & (length-1) 的值才会和 h % length 计算的结果是一样的。这就是它的原因所在。另外，当length是2的整次幂的时候，length-1的结果都是低位全部是1，为后面的扩容做了很好的准备，这里先不扯这个，先理解一下这个意思。

我们来写个单元测试验证下：

    public static void main(String[] args) {
        
        //定义数组长度为2的整次幂，2^4
        int  length  = 16;
        //定义key，并计算k的hash值
        String k = "China";
        int h = k.hashCode();
        //分别使用两种方式计算在数组中的位置
        int index1 = h % length;
        int index2 = h & (length - 1);
        //验证结果
        System.out.println(index1 == index2);
            //结果为 true
    }

    public static void main(String[] args) {
        
        //假设数组长度不是2的整次幂，2^4-1
        int    length  = 15;
        //定义key，并计算k的hash值
        String k = "China";
        int h = k.hashCode();
        //分别使用两种方式计算在数组中的位置
        int index1 = h % length;
        int index2 = h & (length - 1);
        //验证结果
        System.out.println(index1 == index2);
        //打印结果：false
    }

一个可视化的计算过程熟悉一下每种二进制运算符：

计算 8 & 6 = 0的过程如下：

        1 0 0 0    // 8的二进制数
    &   0 1 1 0    // 6的二进制数
    ___________    // 运算规则：该位置上有一个是0 结果就是0
        0 0 0 0    // 二进制数计算结果

答：HashMap 中equals 相同的两个key，容器中只会保留后进来的key 的value。进入问题中即：我先存储了 Lucy的信息，后来又有一个 Lucy，这个时候再存储 Lucy，容器中保留的是第二个 Lucy 的信息，这种情况，我们可以考虑使用 List<T> 作为 value，把相同名字的职员信息存在 list 中；或者给相同名字的职员编号，使得每个key 都是唯一的。

3、HashMap和HashTable 的异同？

二者的存储结构和解决冲突的方法都是相同的。

	HashMap出现于：JDK1.2	HashTable出现于：JDK1.0	CurrentHashMap出现于：JDK1.5
存储方式：	数组+链表		segment+数组+链表
在不指定容量的情况下的默认容量	16	11	segment位16个，桶的数量是16，桶内hash表的数量是1
扩容后容量	容量变为原来的2倍	原来的2倍+1
扩容因子	0.75
扩容点规则(什么时候扩容)：	16*0.75=12	110.75=12, (int)Math.min(newCapacity loadFactor, MAX_ARRAY_SIZE + 1); MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;	当往hashMap中成功插入一个key/value节点时，有可能触发扩容动作： 1、如果新增节点之后，所在链表的元素个数达到了阈值 8，则会调用treeifyBin方法把链表转换成红黑树，不过在结构转换之前，会对数组长度进行判断，实现如下：如果数组长度n小于阈值MIN_TREEIFY_CAPACITY，默认是64，则会调用tryPresize方法把数组长度扩大到原来的两倍，并触发transfer方法，重新调整节点的位置。 2、新增节点之后，会调用addCount方法记录元素个数，并检查是否需要进行扩容，当数组元素个数达到阈值时，会触发transfer方法，重新调整节点的位置。
扩容条件	扩容条件： 1、判断当前个数是否大于等于阈值 2、当前存放是否发生哈希碰撞
底层数组的容量	要求一定为2的整数次幂	不要求一定要为2的整数次幂
能否为null	key和value都允许为 null（key只能有一个为null，而value则可以有多个为 null）	key和 value都不允许为 null（但是如果在 Hashtable中有类似 put( null, null)的操作，编译同样可以通过，因为 key和 value都是Object类型，但运行时会抛出 NullPointerException异常。）

hash 值	重新计算了key的hash值	计算hash值，直接用key的hashCode()
在计算hash值对应的位置索引时	&运算	%运算
线程安全	否	是
	去掉了 Hashtable 中的 contains 方法
父类	继承自 AbstractMap 类	继承自 Dictionary 类
线程安全问题	不安全	安全。HashTable相关操作都是对方法加synchronized的大锁，效率比较低。	安全。ConcurrentHashMap避免了对全局加锁改成了局部加锁操作，这样就极大地提高了并发环境下的操作速度。

关于ConcurrentHashMap：

由于ConcurrentHashMap在JDK1.7和1.8中的实现非常不同，接下来我们谈谈JDK在1.7和1.8中的区别：在JDK1.7中ConcurrentHashMap采用了数组+Segment+分段锁的方式实现。在数组基础上增加了一层Segment，一个Segment对应数组的一段，这样对某段进行的操作只需要锁住对应段，不影响其他段的操作。其中，Segment继承了ReentrantLock并实现了序列化接口，说明Segment的锁是可重入的。
缺点：
ConcurrentHashMap比HashMap多了一次hash过程，第1次hash定位到Segment，第2次hash定位到HashEntry，然后链表搜索找到指定节点。

优点：
在进行写操作时，只需锁住写元素所在的Segment即可，其他Segment无需加锁，提高了并发读写的效率。

ConcurrentHashMap是线程安全的？其中存储的键对象不可以重复？值对象不能重复？

4、如何优化 HashMap？

初始化 HashMap 的时候，我们可以自定义数组容量及加载因子的大小。所以，优化 HashMap 从这两个属性入手，但是，如果你不能准确的判别你的业务所需的大小，请使用默认值，否则，一旦手动配置的不合适，效果将适得其反。

threshold = (int)( capacity * loadFactor );

阈值 = 容量 X 负载因子；

初始容量默认为16,负载因子(loadFactor)默认是0.75; map扩容后，要重新计算阈值；当元素个数大于新的阈值时，map再自动扩容；以默认值为例，阈值=16*0.75=12，当元素个数大于12时就要扩容；那剩下的4个数组位置还没有放置对象就要扩容，造成空间浪费，所以要进行时间和空间的折中考虑；

loadFactor过大时，map内的数组使用率高了，内部极有可能形成Entry链，影响查找速度；

loadFactor过小时，map内的数组使用率较低，不过内部不会生成Entry链，或者生成的Entry链很短，由此提高了查找速度，不过会占用更多的内存；所以可以根据实际硬件环境和程序的运行状态来调节loadFactor；

所以，务必合理的初始化 HashMap

hashCode 与 equals

两个对象的 hashCode() 相同，则 equals() 也一定为 true，对吗？

为什么重写equals时必须重写hashCode方法

hashCode() 的作用是获取哈希码，也称为散列码；它实际上是返回一个int整数。这个哈希码的作用是确定该对象在哈希表中的索引位置。hashCode() 定义在JDK的Object.java中，这就意味着Java中的任何类都包含有hashCode()函数。散列表存储的是键值对(key-value)，它的特点是：能根据“键”快速的检索出对应的“值”。这其中就利用到了散列码（可以快速找到所需要的对象）

当把对象加入 HashSet 时，HashSet 会先计算对象的 hashcode 值来判断对象加入的位置，同时也会与其他已经加入的对象的 hashcode 值作比较，如果没有相符的hashcode，HashSet会假设对象没有重复出现。但是如果发现有相同 hashcode 值的对象，这时会调用 equals()方法来检查 hashcode 相等的对象是否真的相同。如果两者相同，HashSet 就不会让其加入操作成功。如果不同的话，就会重新散列到其他位置。这就是HashSet检查重复的方法，这种方法大大减少了 equals 的次数，相应就大大提高了执行速度。hashCode() 的默认行为是对堆上的对象产生独特值。因此如果两个对象相等，则hashcode一定相同；那么，如果hashcode相同，两个对象就一定相等吗，答案是否定的，两个对象有相同的hashcode值，它们也不一定相等，有一个概念叫hash冲突，在产生hash冲突时,两个不相等的对象就会有相同的 hashcode 值，当hash冲突产生时，一般有以下几种方式来处理：

        1.拉链法:每个哈希表节点都有一个next指针,多个哈希表节点可以用next指针构成一个单向链表，被分配到同一个索引上的多个节点可以用这个单向链表进行存储。
        2.开放定址法:一旦发生了冲突,就去寻找下一个空的散列地址,只要散列表足够大,空的散列地址总能找到,并将记录存入。
        3.再哈希:又叫双哈希法,有多个不同的Hash函数.当发生冲突时,使用第二个,第三个….等哈希函数计算地址,直到无冲突。

可以在hashcode中使用随机数字吗?

不行,因为同一对象的 hashcode 值必须是相同的.

两个对象相等，对两个对象分别调用equals方法都返回true。如果没有重写 hashCode()，则该 class 的两个对象无论如何都不会相等（即使这两个对象指向相同的数据）

因此，equals 方法被覆盖过，则 hashCode 方法也必须被覆盖

对象的相等与指向他们的引用相等，两者有什么不同？

对象的相等比的是内存中存放的内容是否相等而引用相等比较的是他们指向的内存地址是否相等。

以下说法正确的是

ArrayList的写性能要优于LinkedList，在写多于读的场景，建议使用ArrayList；

For循环以及迭代循环遍历一个LinkedList的效果都是一样的；

HashMap是由数组、链表、红黑树组成，链表长度超过阈值时，会再转红黑树；

JDK1.8版本中，HashMap使用了红黑树优化哈希碰撞所带来的链表过长的问题。

肆〇

关注

3
点赞
踩
5

收藏

觉得还不错? 一键收藏
打赏
0
评论
关于java中的容器、集合（Array、List、Map、Set......）

MapMap集合概述和特点概述：将键映射到值的对象一个映射不能包含重复的键每个键最多只能映射到一个值Map接口和Collection接口的不同Map是双列的,Collection是单列的Map的键唯一,Collection的子体系Set是唯一的Map集合的数据结构针对键有效，跟值无关;Collection集合的数据结构是针对元素有效Map集合的功能概述a:添加功能V put(K key,V value):添加元素。这个其实还有另一个功能?替换如果键是第一次存储，就直接存储元素，
复制链接

扫一扫