java集合框架List
1、说下Vector和ArrayList、LinkedList联系和区别？分别的使用场景
线程安全:
ArrayList：底层是数组实现，线程不安全，查询和修改非常快，但是增加和删除慢
LinkedList: 底层是双向链表，线程不安全，查询和修改速度慢，但是增加和删除速度快
Vector: 底层是数组实现，线程安全的，操作的时候使用synchronized进行加锁
使用场景:
Vector已经很少用了
增加和删除场景多则用LinkedList
查询和修改多则用ArrayList
2、如果需要保证线程安全，ArrayList应该怎么做，用有几种方式
方式一：自己写个包装类，根据业务一般是add/update/remove加锁;
方式二：Collections.synchronizedList(new ArrayList<>()); 使用synchronized加锁;
方式三：CopyOnWriteArrayList<>() 使用ReentrantLock加锁.
3、如果回答到上面的点则继续问，没回到到则问，了解CopyOnWriteArrayList吗？和 Collections.synchronizedList实现线程安全有什么区别, 使用场景是怎样的？
CopyOnWriteArrayList：执行修改操作时，会拷贝一份新的数组进行操作（add、set、remove等)，代价十分昂贵，在执行完修改后将原来集合指向新的集合来完成修改操作，源码里面用ReentrantLock可重入锁来保证不会有多个线程同时拷贝一份数组；
场景：读高性能，适用读操作远远大于写操作的场景中使用(读的时候是不需要加锁的，直接获取，删除和增加是需要加锁的, 读多写少)；
Collections.synchronizedList：线程安全的原因是因为它几乎在每个方法中都使用了synchronized同步*锁；
场景：写操作性能比CopyOnWriteArrayList好，读操作性能并不如CopyOnWriteArrayList。
4、CopyOnWriteArrayList的设计思想是怎样的,有什么缺点？
答案：设计思想：读写分离+最终一致；
缺点：内存占用问题,写时复制机制,内存里会同时驻扎两个对象的内存，旧的对象和新写入的对象，如果对象大则容易发生Yong GC和Full GC。
5、ArrayList的扩容机制是怎样的
扩容实现步骤
总的来说就是分两步：
1、扩容
把原来的数组复制到另一个内存空间更大的数组中
2、添加元素
把新元素添加到扩容以后的数组中
核心代码：
//计算容量+确保容量
private void ensureCapacityInternal(int minCapacity){
//如果是初次扩容，则使用默认的容量
if(elementData == EMPTY_ELEMENT_DATA){
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
//是否需要扩容，需要的最少容量大于现在数组的长度则要扩容
if(minCapacity - elementData.length > 0){
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity>>1);
//如果新容量 < 最小容量， 则讲最新的容量赋值给新的容量
if(newCapacity - minCapacity < 0){
newCapacity = minCapacity;
}
//创建新数组
Object[] objects = new Object[newCapacity];
//将旧的数组复制到新的数组里面
System.arraycopy(elementData,0, objects,0,elementData.length);
//修改引用
elementData = objects;
}
}
java集合框架Map
1、用过哪些Map的实现？
HashMap、Hashtable、LinkedHashMap、TreeMap、ConcurrentHashMap.
2、HashMap和Hashtable 的区别
HashMap：底层是基于数组+链表，非线程安全的，默认容量是16、允许有空的健和值
Hashtable：基于哈希表实现，线程安全的(加了synchronized)，默认容量是11，不允许有null的健和值
3、对象的 hashCode()和equals()，使用场景
hashcode:
顶级类Object里面的方法，所有的类都是继承Object,返回是一个int类型的数
根据一定的hash规则(存储地址，字段，长度等)，映射成一个数组，即散列值;
equals
顶级类Object里面的方法，所有的类都是继承Object,返回是一个boolean类型
根据自定义的匹配规则，用于匹配两个对象是否一样，一般逻辑如下:
//判断地址是否一样
//非空判断和Class类型判断
//强转
//对象里面的字段一一匹配
使用场景：对象比较、或者集合容器里面排重、比较、排序
4、编写一个User对象，重写里面的hashcode和equal方法
import java.util.Date;
import java.util.Objects;
public class User {
private int age;
private String name;
private Date time;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Date getTime() {
return time;
}
public void setTime(Date time) {
this.time = time;
}
@Override
public int hashCode() {
//int code = age/name.length()+time.hashCode();
//return code
return Objects.hash(age,name,time);
}
@Override
public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null || getClass() != obj.getClass()) return false;
User user = (User) obj;
return age == user.age && Objects.equals(name, user.name) && Objects.equals(time, user.time);
}
}
5、HashMap和TreeMap应该怎么选择，使用场景
hashMap: 散列桶(数组+链表)，可以实现快速的存储和检索，但是确实包含无序的元素，适用于在map中插入删除和定位元素;
treeMap:使用存储结构是一个平衡二叉树->红黑树，可以自定义排序规则，要实现Comparator接口, 能便捷的实现内部元素的各种排序，但是一般性能比HashMap差，适用于安装自然排序或者自定义排序规则(写过微信支付签名工具类就用这个类).
6、Set和Map的关系
核心就是不保存重复的元素，存储一组唯一的对象;
set的每一种实现都是对应Map里面的一种封装，
HashSet对应的就是HashMap，treeSet对应的就是treeMap
7、常见Map的排序规则是怎样的？
按照添加顺序使用LinkedHashMap，按照自然排序使用TreeMap，自定义排序 TreeMap(Comparetor c)。
8、如果需要线程安全，且效率高的Map，应该怎么做？
多线程环境下可以用concurrent包下的ConcurrentHashMap, 或者使用Collections.synchronizedMap(), ConcurrentHashMap虽然是线程安全，但是他的效率比Hashtable要高很多
9、为什么Collections.synchronizedMap后是线程安全的？
使用Collections.synchronizedMap包装后返回的map是加锁的
10、介绍下你了解的HashMap
HashMap底层(数组+链表+红黑树 jdk8才有红黑树); 数组中每一项是一个链表，即数组和链表的结合体.
Node<K,V>[] table 是数组，数组的元素是Entry(Node继承Entry)，Entry元素是一个key-value的键值对，它持有一个指向下个Entry的引用，table数组的每个Entry元素同时也作为当前Entry链表的首节点，也指向了该链表的下个Entry元素.
在JDK1.8中，链表的长度大于8，链表会转换成红黑树.
HashMap
11、解释下什么是Hash碰撞？常见的解决办法有哪些，hashmap采用哪种方法
hash碰撞的意思是不同key计算得到的Hash值相同，需要放到同个bucket中;
常见的解决办法：链表法、开发地址法、再哈希法等;
HashMap采用的是链表法;
12、HashMap底层是 数组+链表+红黑树，为什么要用这几类结构呢？
数组 Node<K,V>[] table ，根据对象的key的hash值进行在数组里面是哪个节点;
链表的作用是解决hash冲突，将hash值一样的对象存在一个链表放在hash值对应的槽位;
红黑树 JDK8使用红黑树来替代超过8个节点的链表，主要是查询性能的提升，从原来的O(n)到O(logn),
通过hash碰撞，让HashMap不断产生碰撞，那么相同的key的位置的链表就会不断增长，当对这个Hashmap的相应位置进行查询的时候，就会循环遍历这个超级大的链表，性能就会下降，所以改用红黑树.
13、为啥选择红黑树而不用其他树，比如二叉查找树，为啥不一直开始就用红黑树，而是到8的长度后才变换
二叉查找树在特殊情况下也会变成一条线性结构，和原先的链表存在一样的深度遍历问题，查找性能就会慢，
使用红黑树主要是提升查找数据的速度，红黑树是平衡二叉树的一种，插入新数据后会通过左旋，右旋、变色等操作来保持平衡，解决单链表查询深度的问题;
数据量少的时候操作数据，遍历线性表比红黑树所消耗的资源少，且前期数据少, 平衡二叉树保持平衡是需要消耗资源的，所以前期采用线性表，等到一定数之后变换到红黑树.
红黑树
14、说下hashmap的put和get的核心逻辑（JDK8以上版本）
put核心流程:
hashmap的put
get核心流程：
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
//获取首节点，hash碰撞概览小，通常链表第一个节点就是值，没必要去循环遍历，处于效率
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
//如果不止一个节点，就需要循环遍历，存在多个hash碰撞
if ((e = first.next) != null) {
//判断是否是红黑树，如果是则调用树的查找
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
//链表结构，则循环遍历获取节点
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
15、了解ConcurrentHashMap吗？为什么性能比hashtable高，说下原理
ConcurrentHashMap线程安全的Map, hashtable类基本上所有的方法都是采用synchronized进行线程安全控制, 高并发情况下效率就降低;
ConcurrentHashMap是采用了分段锁的思想提高性能，锁粒度更细化.
16、jdk1.7和jdk1.8里面ConcurrentHashMap实现的区别有没了解
JDK8之前，ConcurrentHashMap使用锁分段技术，将数据分成一段段存储，每个数据段配置一把锁，即segment类，这个类继承ReentrantLock来保证线程安全
技术点：Segment+HashEntry
JKD8的版本取消Segment这个分段锁数据结构，底层也是使用Node数组+链表+红黑树，从而实现对每一段数据就行加锁，也减少了并发冲突的概率，CAS(读)+Synchronized(写)
技术点：Node+Cas+Synchronized
17、说下ConcurrentHashMap的put的核心逻辑（JDK8以上版本）
spread(key.hashCode()) 重哈希，减少碰撞概率
tabAt(i) 获取table中索引为i的Node元素
casTabAt(i) 利用CAS操作获取table中索引为i的Node元素
put的核心流程:
1、key进行重哈希spread(key.hashCode())
2、对当前table进行无条件循环
3、如果没有初始化table，则用initTable进行初始化
4、如果没有hash冲突，则直接用cas插入新节点，成功后则直接判断是否需要扩容，然后结束
5、(fh = f.hash) == MOVED 如果是这个状态则是扩容操作，先进行扩容
6、存在hash冲突，利用synchronized (f) 加锁保证线程安全
7、如果是链表，则直接遍历插入，如果数量大于8，则需要转换成红黑树
8、如果是红黑树则按照红黑树规则插入
9、最后是检查是否需要扩容addCount()
网友评论