java Arraylist扩容为啥是1.5倍+1

Posted 2023-05-07

// ArrayList类的源码：对内部数组扩容 
public void ensureCapacity(int minCapacity) 
 modCount++;
 int oldCapacity = elementData.length;
 if (minCapacity > oldCapacity) 
     Object oldData[] = elementData;
     int newCapacity = (oldCapacity * 3)/2 + 1;// 计算新容量
     if (newCapacity < minCapacity) newCapacity = minCapacity;
     // minCapacity is usually close to size, so this is a win:
     elementData = Arrays.copyOf(elementData, newCapacity);
 

追问

我看过源代码，知道是这么写的，不过，为什么扩容那么大，是研究过效率得出的吗？

追答

这个应该是有一定依据的，呵呵，不确定。
此方法是public的，需要时可以自己重载。
比如根据modCount（也就是扩容次数），重新实现为如果modCount>10，那么一次扩容10倍。因为扩容涉及到数据的移动，效率会有点低。

参考技术A 您好，提问者：
因为0的1.5还是0。
确切的来说应该是：+1的1.5倍。

2023面试专题：JAVA基础

ArrayList和LinkedList有哪些区别

ArrayList扩容机制:

• ArrayList() 会使用长度为零的数组
• ArrayList(int initialCapacity) 会使用指定容量的数组
• public ArrayList(Collection<? extends E> c) 会使用 c 的大小作为数组容量
• add(Object o) 首次扩容为 10，再次扩容为上次容量的 1.5 倍
• addAll(Collection c) 没有元素时，扩容为 Math.max(10, 实际元素个数)，有元素时为 Math.max(原容量 1.5 倍, 实际元素个数)

1. ⾸先，他们的底层数据结构不同，ArrayList底层是基于数组实现的，LinkedList底层是基于链表实 现的
2. 由于底层数据结构不同，他们所适⽤的场景也不同，ArrayList更适合随机查找，LinkedList更适合 删除和添加，查询、添加、删除的时间复杂度不同
3. 另外ArrayList和LinkedList都实现了List接⼝，但是LinkedList还额外实现了Deque接⼝，所以 LinkedList还可以当做队列来使⽤

fail-fast 与 fail-safe

ArrayList 是 fail-fast 的典型代表，遍历的同时不能修改，尽快失败

CopyOnWriteArrayList 是 fail-safe 的典型代表，遍历的同时可以修改，原理是读写分离

所以ArrayList是非线程安全的，CopyOnWriteArrayList线程安全

掌握 ArrayList 与 LinkedList 的比较

• ArrayList

基于数组，需要连续内存

随机访问快（指根据下标访问）

尾部插入、删除性能可以，其它部分插入、删除都会移动数据，因此性能会低

可以利用 cpu 缓存，局部性原理 （了解）

• LinkedList

• • 基于双向链表，无需连续内存
  • 随机访问慢（要沿着链表遍历）
  • 头尾插入删除性能高
  • 占用内存多

4.HashMap

4.1底层数据结构

• 1.7 数组 + 链表
• 1.8 数组 + （链表 | 红黑树）

jdk1.7

1) 初始化一个数组(默认长度16)

2) 当put 值时,计算key的hash值，二次hash然后对数组长度取模，对应到数组下标

3) 如果没有产生hash冲突(下标位置没有元素)，则直接创建Node存入数组

4) 如果产生hash冲突，先进行equal比较，相同则取代该元素，不同，则插入链表

jdk8开始链表高度到8、数组长度超过64，链表转变为红黑树，元素以内部类Node节点存在

1) 计算key的hash值，二次hash然后对数组长度取模，对应到数组下标，

2) 如果没有产生hash冲突(下标位置没有元素)，则直接创建Node存入数组，

3) 如果产生hash冲突，先进行equal比较，相同则取代该元素，不同，则判断链表高度插入链表，链

表高度达到8，并且数组长度到64则转变为红黑树，长度低于6则将红黑树转回链表

4) 如果存储的数据 key为null，存在下标0的位置

总结：

1.树化 ：单个槽中链表长度 > 8 a.数组容量如果小于64，优先扩容 b.如果数组容量大于等64，转红黑树

2.树退化: a.扩容时，原来红黑树上一部分数据可能会转移到别的槽中，当红黑树中的元素小于等于6时，退化成链表

b.调用remove方法删除数据时，删除之前校验红黑树根节点 左儿子 左孙子 右儿子是否存在，如果有一个不存在，退化成链表

put总结：

1.key 计算 两次hash值，用当前数组长度取模，得到桶下标

2.将数据插入到桶中（链表/红黑树） 1.7头插法 1.8尾插法

2.1 总容量 >= 64 并且 链表长度 达到8个，1.8转成红黑树

3.检查是否需要扩容，如果满足扩容条件（元素个数 > 容量 * 加载因子0.75），触发扩容 容量 * 2,将原数据

搬运到新的数组中

4.2 HashMap的扩容机制原理

1.7版本

1. 先⽣成新数组

2. 遍历⽼数组中的每个位置上的链表上的每个元素

3. 取每个元素的key，并基于新数组⻓度，计算出每个元素在新数组中的下标

4. 将元素添加到新数组中去

5. 所有元素转移完了之后，将新数组赋值给HashMap对象的table属性

1.8版本

1. 先⽣成新数组

2. 遍历⽼数组中的每个位置上的链表或红⿊树

3. 如果是链表，则直接将链表中的每个元素重新计算下标，并添加到新数组中去

4. 如果是红⿊树，则先遍历红⿊树，先计算出红⿊树中每个元素对应在新数组中的下标位置

a. 统计每个下标位置的元素个数

b. 如果该位置下的元素个数超过了8，则⽣成⼀个新的红⿊树，并将根节点的添加到新数组的对

应位置

c. 如果该位置下的元素个数没有超过8，那么则⽣成⼀个链表，并将链表的头节点添加到新数组

的对应位置

5. 所有元素转移完了之后，将新数组赋值给HashMap对象的table属性

1. 链表插入节点时，1.7 是头插法，1.8 是尾插法
2. 1.7 是大于等于阈值且没有空位时才扩容，而 1.8 是大于阈值就扩容

5.设计模式

见设计模式专题

面向对象的特征？

面向对象的特征：封装、继承、多态、抽象。

封装：就是把对象的属性和行为（数据）结合为一个独立的整体，并尽可能隐藏对象的内部实现细节，就是把不想告诉或者不该告诉别人的东西隐藏起来，把可以告诉别人的公开，别人只能用我提供的功能实现需求，而不知道是如何实现的。增加安全性。

继承：子类继承父类的数据属性和行为，并能根据自己的需求扩展出新的行为，提高了代码的复用性。

多态：指允许不同的对象对同一消息做出相应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式（发送消息就是函数调用）。封装和继承几乎都是为多态而准备的，在执行期间判断引用对象的实际类型，根据其实际的类型调用其相应的方法。

抽象：表示对问题领域进行分析、设计中得出的抽象的概念，是对一系列看上去不同，但是本质上相同的具体概念的抽象。在Java 中抽象用 abstract 关键字来修饰，用abstract 修饰类时，此类就不能被实例化，从这里可以看出，抽象类（接口）就是为了继承而存在的。

& 和 && 的区别？

&运算符有两种用法:

按位与;

逻辑与。

&&运算符是短路与运算。逻辑与跟短路与的差别是非常巨大的，虽然二者都要求运算符左右两端的布尔值都是 true 整个表达式的值才是 true。

&&之所以称为短路运算是因为，如果&&左边的表达式的值是 false，右边的表达式会被直接短路掉，不会进行 运算。很多时候我们可能都需要用&&而不是&，例如在验证用户登录时判定用户名不是 null 而且不是空字符串，应当写为

username != null &&!username.equals("")，二者的顺序不能交换，更不能用&运算符，因为第一个条件如果不成立，根本不能进行字符串的 equals 比较，否则会产生NullPointerException 异常。

注意:逻辑或运算符(|) 和短路或运算符(||)的差别也是如此。

Java 的基本数据类型有哪些？

其中byte、short、int、long都是表示整数的，只不过他们的取值范围不一样

• byte的取值范围为-128~127，占用1个字节(-2的7次方到2的7次方-1)
• short的取值范围为-32768~32767，占用2个字节(-2的15次方到2的15次方-1)
• int的取值范围为(-2147483648~2147483647)，占用4个字节(-2的31次方到2的31次方-1)
• long的取值范围为(-9223372036854774808~9223372036854774807)，占用8个字节(-2的63次方到2的63次方-1)

简述Java 中的值传递和引用传递?

1.值传递

在方法的调用过程中，实参把它的实际值传递给形参，此传递过程就是将实参的值复制

一份传递到函数中，这样如果在函数中对该值（形参的值）进行了操作将不会影响实参的值。因为是直接复制，所以这种方式在传递大量数据时，运行效率会特别低下。

2、引用传递

引用传递弥补了值传递的不足，如果传递的数据量很大，直接复过去的话，会占用大量

的内存空间，而引用传递就是将对象的地址值传递过去，函数接收的是原始值的首地址值。

在方法的执行过程中，形参和实参的内容相同，指向同一块内存地址，也就是说操作的其实都是源数据，所以方法的执行将会影响到实际对象

结论：

基本数据类型传值，对形参的修改不会影响实参；

引用类型传引用，形参和实参指向同一个内存地址（同一个对象），所以对参数的修改会影响到实际的对象。String, Integer, Double 等 immutable 的类型特殊处理，可以理解为传值，最后的操作不会修改实参对象。

参考阅读：

java值传递和引用传递（附实例）_V5放纵丶的博客-CSDN博客_引用传递的例子

char 型变量中能不能存储一个中文汉字，为什么?

类型可以存储一个中文汉字，因为Java 中使用的编码是 Unicode(不选择任何特定的

编码，直接使用字符在字符集中的编号，这是统一的唯一方法)，一个 char 类型占 2 个字节(16 比特)，所以放一个中文是没问题的

unicode编码和utf-8编码的区别_小唐要努力的博客-CSDN博客_unicode和utf-8的区别

重载和重写的区别？

重载：发生在同一个类中，方法名必须相同，参数类型不同、个数不同、顺序不同会让这两个方法成为不同的方法，但是方法返回值和访问修饰符的不同不会影响，发生在编译时。

重写：发生在父子类中，方法名、参数列表必须相同，返回值范围小于等于父类，抛出的异常范围小于等于父类，访问修饰符范围大于等于父类；如果父类方法访问修饰符为private 则子类就不能重写该方法。

==与equals的区别？

对于==，如果作用于基本数据类型的变量，则直接比较其存储的 “值”是否相等；如果作用于引用类型的变量，则比较的是所指向的对象的地址。

对于equals方法，注意：equals方法不能作用于基本数据类型的变量；

如果没有对equals方法进行重写，则比较的是引用类型的变量所指向的对象的地址；

诸如String、Date等类对equals方法进行了重写的话，比较的是所指向的对象的内容。

String、StringBuffer、StringBuilder 的区别？

String 是不可变的对象，每次对 String 类型进行改变的时候其实是产生了一个新的 String 对象，然后指针指向新的 String 对象；

StringBuffer 是线程安全的可变字符序列。

StringBuilder 线程不安全，速度更快，单线程使用。

（String 是一个类，但却是不可变的，所以 String 创建的算是一个字符串常量， StringBuffer 和 StringBuilder 都是可变的。所以每次修改 String 对象的值都是新建一个对象再指向这个对象。而使用 StringBuffer 则是对 StringBuffer 对象本身进行操作。所以在字符串 j 经常改变的情况下，使用 StringBuffer 要快得多。）

对于三者使用的总结：

1. 操作少量的数据 = String

2. 单线程操作字符串缓冲区下操作大量数据 = StringBuilder

3. 多线程操作字符串缓冲区下操作大量数据 = StringBuffffer

final 关键字的一些用法？

final关键字主要用在三个地方：变量、方法、类。

对于一个final变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。

当用final修饰一个类时，表明这个类不能被继承。final类中的所有成员方法都会被隐式地指定为final方法。

使用final方法的原因有两个：

第一个原因是把方法锁定，以防任何继承类修改它的含义；

第二个原因是效率。

在早期的Java实现版本中，会将final方法转为内嵌调用。但是如果方法过于庞大，可能看不到内嵌调用带来的任何性能提升（现在的Java版本已经不需要使用final方法进行这些优化了）。类中所有的private方法都隐式地指定为final。

Object类是一个特殊的类，是所有类的父类。

它主要提供了以下11个方法：

public final native Class<?> getClass()//native方法，用于返回当前运行时对象的Class对象，使用了final关键字修饰，故不允许子类重写。

public native int hashCode() //native方法，用于返回对象的哈希码，主要使用在哈希表中，比如JDK中的HashMap。

public boolean equals(Object obj)//用于比较2个对象的内存地址是否相等，String类对该方法进行了重写用户比较字符串的值是否相等。

protected native Object clone() throws CloneNotSupportedException//naitive方法，用于创建并返回当前对象的一份拷贝。一般情况下，对于任何对象 x，表达式 x.clone() != x 为true，x.clone().getClass()

== x.getClass() 为true。Object本身没有实现Cloneable接口，所以不重写clone方法并且进行调用的话会发生CloneNotSupportedException异常。

public String toString()//返回类的名字@实例的哈希码的16进制的字符串。建议Object所有的子类都重写这个方法。

public final native void notify()//native方法，并且不能重写。唤醒一个在此对象监视器上等待的线程(监视器相当于就是锁的概念)。如果有多个线程在等待只会任意唤醒一个。

public final native void notifyAll()//native方法，并且不能重写。跟notify一样，唯一的区别就是会唤醒在此对象监视器上等待的所有线程，而不是一个线程。

public final native void wait(long timeout) throws InterruptedException//native方法，并且不能重写。暂停线程的执行。注意：sleep方法没有释放锁，而wait方法释放了锁 。timeout是等待时间。

public final void wait(long timeout, int nanos) throws InterruptedException//多了nanos参数， 这个参数表示额外时间（以毫微秒为单位，范围是 0-999999）。 所以超时的时间还需要加上nanos毫秒。

public final void wait() throws InterruptedException//跟之前的2个wait方法一样，只不过该方法一直等待，没有超时时间这个概念

protected void finalize() throws Throwable //实例被垃圾回收器回收的时候触发的操作

接口和抽象类的区别是什么？

实现：抽象类的子类使用extends 来继承；接口必须使用 implements 来实现接口。

构造函数：抽象类可以有构造 函数；接口不能有。

main 方法：抽象类可以有 main 方法，并且我们能运行它；接口不能有 main方法。

实现数量：类可以实现很多个接口；但是只能继承一个抽象类。

访问修饰符：接口中的方法默认使用public 修饰；抽象类中的方法可以是任意访问修饰符。

throw 和 throws 的区别？

throw:

1)throw 语句用在方法体内，表示抛出异常，由方法体内的语句处理。

2)throw 是具体向外抛出异常的动作，所以它抛出的是一个异常实例，执行 throw 一定是

抛出了某种异常。

throws:

1)throws 语句是用在方法声明后面，表示如果抛出异常，由该方法的调用者来进行异常的

处理。

2)throws 主要是声明这个方法会抛出某种类型的异常，让它的使用者要知道需要捕获的异

常的类型。

3)throws 表示出现异常的一种可能性，并不一定会发生这种异常。

请写出你最常见的5 个 RuntimeException？

下面列举几个常见的RuntimeException。

1)java.lang.NullPointerException 空指针异常;出现原因:调用了未经初始化的对象或者是不存在的对象。

2)java.lang.ClassNotFoundException 指定的类找不到;出现原因:类的名称和路径加载错误;通常都是程序试图通过字符串来加载某个类时可能引发异常。

3)java.lang.NumberFormatException 字符串转换为数字异常;出现原因:字符型数据中包含非数字型字符。

4)java.lang.IndexOutOfBoundsException 数组角标越界异常，常见于操作数组对象时发生。

5)java.lang.IllegalArgumentException 方法传递参数错误。

6)java.lang.ClassCastException 数据类型转换异常。

java 异常处理机制？

error 和 exception 的区别

线上问题综合解决方案 《线上问题综合解决方案》，可复制链接后用石墨文档 App 打开

Set,List,Map 有什么区别？

结构特点

List 和 Set 是存储单列数据的集合， Map 是存储键和值这样的双列数据的集合；

List 中存储的数据是有顺序，并且允许重复； Map 中存储的数据是没有顺序的，其键是不能重复的，它的值是可以有重复的， Set 中存储的数据是无序的，且不允许有重复，但元素在集合中的位置由元素的 hashcode 决定，位置是固定的（Set 集合根据 hashcode 来进行数据的存储，所以位置是固定的，但是位置不是用户可以控制的，所以对于用户来说 set 中的元素还是无序的）；

实现类

List 接口有三个实现类（LinkedList：基于链表实现，链表内存是散乱的，每一个元素存

储本身内存地址的同时还存储下一个元素的地址。链表增删快，查找慢；ArrayList：基于

数组实现，非线程安全的，效率高，便于索引，但不便于插入删除；Vector：基于数组实

现，线程安全的，效率低）。

Map 接口有三个实现类（HashMap：基于 hash 表的 Map 接口实现，非线程安全，高效，支 持 null 值和 null 键； HashTable：线程安全，低效，不支持 null 值和 null 键；

LinkedHashMap：是 HashMap 的一个子类，保存了记录的插入顺序；

SortMap 接口：TreeMap，能够把它保存的记录根据键排序，默认是键值的升序排序）。

Set 接口有两个实现类（HashSet：底层是由 HashMap 实现，不允许集合中有重复的值，使用该方式时需要重写 equals()和 hashCode()方法； LinkedHashSet：继承与 HashSet，同时又基于 LinkedHashMap 来进行实现，底层使用的是 LinkedHashMp）

区别

List 集合中对象按照索引位置排序，可以有重复对象，允许按照对象在集合中的索引位置检索对象，例如通过list.get(i)方法来获取集合中的元素；

Map 中的每一个元素包含一个键和一个值，成对出现，键对象不可以重复，值对象可以重复；

Set 集合中的对象不按照特定的方式排序，并且没有重复对象，但它的实现类能对集合中

的对象按照特定的方式排序，例如TreeSet 类，可以按照默认顺序，也可以通过实现 Java.util.Comparator 接口来自定义排序方式。

往ArrayList 集合加入一万条数据，应该怎么提高效率？

ArrayList 的构造方法有三种。当数据量比较大，这里又已经明确是一万条了，我们应该在

初始化的时候就给它设置好容量。

ArrayList 默认容量是 10，如果初始化时一开始指定了容量，或者通过集合作为元素，则容量为指定的大小或参数集合的大小。每次扩容为原来的 1.5 倍，如果使用无参构造器初始容量只有 10，后面要扩容，扩容又比较伤性能，因为涉及到数组的复制和移动，将原来的数组复制到新的存储区域中去。

Hashmap、hashtable、ConcurrentHashMap区别？

区别对比一(HashMap 和 HashTable 区别)：

1、HashMap 是非线程安全的，HashTable 是线程安全的。

2、HashMap 的键和值都允许有 null 值存在，而 HashTable 则不行。3、因为线程安全的问题，HashMap 效率比 HashTable 的要高。

4、Hashtable 是同步的，而 HashMap 不是。因此，HashMap 更适合于单线程环境，而 Hashtable 适合于多线程环境。一般现在不建议用 HashTable, ① 是 HashTable 是遗留类，内部实现很多没优化和冗余。②即使在多线程环境下， 现在也有同步的ConcurrentHashMap 替代，没有必要因为是多线程而用HashTable。

区别对比二(HashTable 和 ConcurrentHashMap 区别)：

HashTable 使用的是 Synchronized 关键字修饰，ConcurrentHashMap 是JDK1.7 使用了锁分段技术来保证线程安全的。JDK1.8ConcurrentHashMap 取消了Segment 分段锁，采用 CAS 和 synchronized 来保证并发安全。数据结构跟 HashMap1.8 的结构类似，数组+链表/红黑二叉树。

synchronized 只锁定当前链表或红黑二叉树的首节点，这样只要 hash 不冲突，就不会产生并发，效率又提升 N 倍。