集合总的接口是 Collection
public interface Collection<E> extends Iterable<E> {
int size();
boolean isEmpty();
boolean contains(Object o);
Iterator<E> iterator();
Object[] toArray();
<T> T[] toArray(T[] a);
boolean add(E e);
boolean remove(Object o);
boolean containsAll(Collection<?> c);
boolean addAll(Collection<? extends E> c);
boolean removeAll(Collection<?> c);
default boolean removeIf(Predicate<? super E> filter) {
Objects.requireNonNull(filter);
boolean removed = false;
final Iterator<E> each = iterator();
while (each.hasNext()) {
if (filter.test(each.next())) {
each.remove();
removed = true;
}
}
return removed;
}
boolean retainAll(Collection<?> c);
void clear();
boolean equals(Object o);
int hashCode();
@Override
default Spliterator<E> spliterator() {
return Spliterators.spliterator(this, 0);
}
// 在这个集合上返回一个顺序流 ，单线程
default Stream<E> stream() {
return StreamSupport.stream(spliterator(), false);
}
// 在这个集合上返回一个并行的代码流 ，多线程
default Stream<E> parallelStream() {
return StreamSupport.stream(spliterator(), true);
}
}
Map接口
public interface Map<K,V> {
int size();
boolean isEmpty();
boolean containsKey(Object key);
boolean containsValue(Object value);
V get(Object key);
V put(K key, V value);
V remove(Object key);
void putAll(Map<? extends K, ? extends V> m);
void clear();
Set<K> keySet();
Collection<V> values();
Set<Map.Entry<K, V>> entrySet();
interface Entry<K,V> {
V getValue();
V setValue(V value);
boolean equals(Object o);
int hashCode();
public static <K extends Comparable<? super K>, V> Comparator<Map.Entry<K,V>> comparingByKey() {
return (Comparator<Map.Entry<K, V>> & Serializable)
(c1, c2) -> c1.getKey().compareTo(c2.getKey());
}
public static <K, V extends Comparable<? super V>> Comparator<Map.Entry<K,V>> comparingByValue() {
return (Comparator<Map.Entry<K, V>> & Serializable)
(c1, c2) -> c1.getValue().compareTo(c2.getValue());
}
public static <K, V> Comparator<Map.Entry<K, V>> comparingByKey(Comparator<? super K> cmp) {
Objects.requireNonNull(cmp);
return (Comparator<Map.Entry<K, V>> & Serializable)
(c1, c2) -> cmp.compare(c1.getKey(), c2.getKey());
}
public static <K, V> Comparator<Map.Entry<K, V>> comparingByValue(Comparator<? super V> cmp) {
Objects.requireNonNull(cmp);
return (Comparator<Map.Entry<K, V>> & Serializable)
(c1, c2) -> cmp.compare(c1.getValue(), c2.getValue());
}
}
boolean equals(Object o);
int hashCode();
default V getOrDefault(Object key, V defaultValue) {
V v;
return (((v = get(key)) != null) || containsKey(key))
? v
: defaultValue;
}
default void forEach(BiConsumer<? super K, ? super V> action) {
Objects.requireNonNull(action);
for (Map.Entry<K, V> entry : entrySet()) {
K k;
V v;
try {
k = entry.getKey();
v = entry.getValue();
} catch(IllegalStateException ise) {
// this usually means the entry is no longer in the map.
throw new ConcurrentModificationException(ise);
}
action.accept(k, v);
}
}
default void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
Objects.requireNonNull(function);
for (Map.Entry<K, V> entry : entrySet()) {
K k;
V v;
try {
k = entry.getKey();
v = entry.getValue();
} catch(IllegalStateException ise) {
// this usually means the entry is no longer in the map.
throw new ConcurrentModificationException(ise);
}
// ise thrown from function is not a cme.
v = function.apply(k, v);
try {
entry.setValue(v);
} catch(IllegalStateException ise) {
// this usually means the entry is no longer in the map.
throw new ConcurrentModificationException(ise);
}
}
}
default V putIfAbsent(K key, V value) {
V v = get(key);
if (v == null) {
v = put(key, value);
}
return v;
}
default boolean remove(Object key, Object value) {
Object curValue = get(key);
if (!Objects.equals(curValue, value) ||
(curValue == null && !containsKey(key))) {
return false;
}
remove(key);
return true;
}
default boolean replace(K key, V oldValue, V newValue) {
Object curValue = get(key);
if (!Objects.equals(curValue, oldValue) ||
(curValue == null && !containsKey(key))) {
return false;
}
put(key, newValue);
return true;
}
default V replace(K key, V value) {
V curValue;
if (((curValue = get(key)) != null) || containsKey(key)) {
curValue = put(key, value);
}
return curValue;
}
default V computeIfAbsent(K key,
Function<? super K, ? extends V> mappingFunction) {
Objects.requireNonNull(mappingFunction);
V v;
if ((v = get(key)) == null) {
V newValue;
if ((newValue = mappingFunction.apply(key)) != null) {
put(key, newValue);
return newValue;
}
}
return v;
}
default V computeIfPresent(K key,
BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
Objects.requireNonNull(remappingFunction);
V oldValue;
if ((oldValue = get(key)) != null) {
V newValue = remappingFunction.apply(key, oldValue);
if (newValue != null) {
put(key, newValue);
return newValue;
} else {
remove(key);
return null;
}
} else {
return null;
}
}
default V compute(K key,
BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
Objects.requireNonNull(remappingFunction);
V oldValue = get(key);
V newValue = remappingFunction.apply(key, oldValue);
if (newValue == null) {
// delete mapping
if (oldValue != null || containsKey(key)) {
// something to remove
remove(key);
return null;
} else {
// nothing to do. Leave things as they were.
return null;
}
} else {
// add or replace old mapping
put(key, newValue);
return newValue;
}
}
default V merge(K key, V value,
BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
Objects.requireNonNull(remappingFunction);
Objects.requireNonNull(value);
V oldValue = get(key);
V newValue = (oldValue == null) ? value :
remappingFunction.apply(oldValue, value);
if(newValue == null) {
remove(key);
} else {
put(key, newValue);
}
return newValue;
}
}
集合之ArrayList篇
ArrayList就是动态数组，实现了List，RandomAccess（快速随机访问），Cloneable（克隆），Serializable（序列化）接口。
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess,Cloneable, Serializable
ArrayList使用方法及源码解析
ArrayList的构造方法：
默认情况下，ArrayList会生成一个Object类型的数组；也可以使用第一个构造方法来初始 化数组的大小；还可以向ArrayList中传入一个Collection类型的容器，将容器数组化并赋值给这个ArrayList。
// 用指定的初始容量构造一个空列表
public ArrayList(int initialCapacity) {
if (initialCapacity > 0) {
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {
this.elementData = EMPTY_ELEMENTDATA;
} else {
throw new IllegalArgumentException("Illegal Capacity: " + initialCapacity);
}
}
// 构造一个初始容量为10的空列表。
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
// 按照集合的迭代器返回的顺序构造一个包含指定集合元素的列表。
public ArrayList(Collection<? extends E> c) {
elementData = c.toArray();
if ((size = elementData.length) != 0) {
// c.toArray可能（不正确）不返回Object []
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, size, Object[].class);
} else {
//用空数组替换。
this.elementData = EMPTY_ELEMENTDATA;
}
}
add方法
add方法主要有四种：
add(Object e)：再末尾添加一个元素
add(int index,Object element)：在指定位置添加一个元素
addAll(int index , Collection c)：在指定位置添加Collection元素，原位置的元素后移
addAll( Collection c)：将Collection元素添加到集合的尾部
- 源码查看 add(Ee) 方法
// 首先，第一步进行增量操作
public boolean add(E e) {
// 判断是否要扩容
ensureCapacityInternal(size + 1); // 增加 modCount!!
elementData[size++] = e;
return true;
}
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
// 返回值为DEFAULT_CAPACITY(长度是10)和size+1大的值
private staticint calculateCapacity(Object[] elementData, int minCapacity {
//如果说数组没有长度的话，需要进行长度赋值
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}
//modCount++，修改次数加1，（主要作用是迭代器遍历初始时会得到这个数，如果遍历时候这个数改变了，就会抛异常，这就是快速失败策略），
//之后比较新增之后的长度和现有数组长度，当新增长度大的时候就应该进行扩容操作，咱们接着看grow（）方法
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
// 首先，数组会扩容原长度的1.5倍，再比较扩容后的长度和上面返回的值（取默认长度10和size+1中大的）比较，取大的值①的代码；
// 如果长度大于Integer.MAX_VALUE – 8 抛异常②处代码。之后进行数组拷贝，new一个新的长度的数组，赋值。
// 由于数组扩容时候也会浪费一定的时间，所以如果可以确定数组长度可以直接赋值1.5倍的长度。
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity - minCapacity < 0) // ①
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0) //②
newCapacity = hugeCapacity(minCapacity);
// minCapacity is usually close to size, so this is a win:
elementData = Arrays.copyOf(elementData, newCapacity);
}
Arrays的copyOf()方法传回的数组是新的数组对象，所以您改变传回数组中的元素值，也不会影响原来的数组。第二个变量指定要建立的新数组长度。
- add(intindex, E element)方法
首先，rangeCheckForAdd(index) 进行检查index是否大于数组长度或者小于0，是抛异常；
其次，ensureCapacityInternal(size+ 1);判断数组是否需要扩容；
最后，复制index位置之后的元素到index+1处，把element插入到index位置，数组长度加1。
public void add(intindex, E element) {
rangeCheckForAdd(index);
ensureCapacityInternal(size + 1); // Increments modCount!!
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
elementData[index] = element;
size++;
}
- addAll(intindex , Collection c)
System.arraycopy(elementData, index,elementData, index + numNew,numMoved);
如果不是在末尾插入，先把原数组index位置之后的数据复制到index+Collection.size 长度之后。
System.arraycopy(a, 0, elementData, index,numNew);
把Collection里的元素复制到index位置
public boolean addAll(int index, Collection<? extends E> c) {
rangeCheckForAdd(index);
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacityInternal(size + numNew); // Increments modCount
int numMoved = size - index;
if (numMoved > 0)
System.arraycopy(elementData, index, elementData, index + numNew, numMoved);
System.arraycopy(a, 0, elementData, index, numNew);
size += numNew;
return numNew != 0;
}
- remove(intindex)
先判断index是否小于0或大于集合长度；
之后判断是否是数组最后一位，不是，复制数组index之后的元素到index位置，最后一位置为null，返回删除元素的值；
public E remove(int index) {
rangeCheck(index);
modCount++;
E oldValue = elementData(index);
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index, numMoved);
elementData[--size] = null; // clear to let GC do its work
return oldValue;
}
- remove(Objecto)
判断传入的元素是否是null，是的话遍历数组，找到null删除，调用fastRemove方法复制index之后的元素到index位置；
不是的话遍历数组，找到和o相等的元素，删除方式同上，如果找不到返回false。
public boolean remove(Object o) {
if (o == null) {
for (int index = 0; index < size; index++)
if (elementData[index] == null) {
fastRemove(index);
return true;
}
} else {
for (int index = 0; index < size; index++)
if (o.equals(elementData[index])) {
fastRemove(index);
return true;
}
}
return false;
}
- removeAll(Collection<?> c)
首先对集合中的对象数组进行了一次复制，然后将数组中的元素依次与collection进行对比。try{}块的结果就是得到了一个数组，数组前w位元素或与collection相同（complement=true的时候)或不同（complement=false)。
下面来看finally,先来看第二个if{}代码块，它的作用就是把数组中w以后的元素全部变为null值，让gc来回收。
现在回到finally的第一个if中，看条件(r != size)，似乎永远不会满足这个条件吧。上面的for循环一直r++啊，可是别忘了，c.contains(elementData[r])这句话是有可能抛出异常的，如果一旦类型不匹配，就会抛出异常 进入finally中。
这个方法，如果没有删除任何数据，那么将会返回false。
public boolean removeAll(Collection<?> c) {
Objects.requireNonNull(c);
return batchRemove(c, false);
}
private boolean batchRemove(Collection<?> c, boolean complement) {
final Object[] elementData = this.elementData;
int r = 0, w = 0;
boolean modified = false;
try {
for (; r < size; r++)
if (c.contains(elementData[r]) == complement)
elementData[w++] = elementData[r];
} finally {
// Preserve behavioral compatibility with AbstractCollection,
// even if c.contains() throws.
if (r != size) {
System.arraycopy(elementData, r,
elementData, w,
size - r);
w += size - r;
}
if (w != size) {
// clear to let GC do its work
for (int i = w; i < size; i++)
elementData[i] = null;
modCount += size - w;
size = w;
modified = true;
}
}
return modified;
}
- set(intindex ,Object element)
直接修改该位置的数据 - get(intindex)
直接拿到该位置数据
其他的一些方法
indexoOf(Object o)：返回列表中第一次出现指定元素的索引，如果此列表不包含元素，则返回-1；
原理：从0开始遍历数组元素。
lastIndexOf(Object o)：返回列表中最后一次出现的指定元素的索引，如果此列表不包含该元素，则返回-1。
原理：从后往前遍历，同上。
clone()：克隆操作，它是浅复制。
toArray()：以适当的顺序（从第一个元素到最后一个元素）返回包含此列表中所有元素的数组。
subList()：该方法返回的原集合的视图，对返回后的值进行操作，原集合也会改变（后面我们在说这个）；生成子列表之后，对原列表进行操作，子列表视图会报异常，所以最好把原列表通过Collections.unmodifiableList方法设成只读状态
其他注意事项
Arrays.asList(data) 返回值为Arrays工具类中的一个内部类，是一个静私有的内部类，没有添加，删除的方法，只能读操作。
Comparable接口可以作为实现类的默认排序法，Comparator接口是一个类的扩展排序工具。
前者应该比较固定，和一个具体类相绑定，而后者比较灵活，它可以被用于各个需要比较功能的类使用。可以说前者属于 “静态绑定”，而后者可以 “动态绑定”
ArrayList线程不安全，可以使用Collections.synchronizedList(newArrayList());解决多线程并发访问集合时候线程安全问题。
利用Iterator遍历集合时候不要对集合进行修改，原因是集合中有个参数modCount，这个参数是记录集合操作次数的如修改，删除，当遍历时候会判断这个参数和最开始遍历时候的值是否相等，不相等直接抛异常（hashNext==true啥时候才进行判断）。
ArrayList实现了RandomAccess接口（随机存取接口），标志ArrayList是一个可以随机存取的列表，RandomAccess和Cloneable，Serializable一样，都是标志性接口，不需要任何的实现，只是表明具有某种特质。
Java中的foreach是Iterator的变形用法，对于ArrayList而言，需要创建一个迭代器容器，屏蔽内部细节，对外提供hasNext，next等方法 ，ArrayList实现RandomAccess接口，表明元素之间没有联系，但迭代器需要建立一个强制互相知晓的关系，如上一个元素可以判断是否还有下一个元素，这就是foreach遍历耗时原因，所以ArrayList直接用get(i)遍历最快，而LinkedList用foreach遍历较好。
总结：
- ArrayList是基于数组实现的，是一个动态数组，其容量能自动增长，类似于C语言中的动态申请内存，动态增长内存。
- ArrayList不是线程安全的，只能用在单线程环境下，多线程环境下可以考虑用Collections.synchronizedList(List l)函数返回一个线程安全的ArrayList类，也可以使用concurrent并发包下的CopyOnWriteArrayList类。
- ArrayList实现了Serializable接口，因此它支持序列化，能够通过序列化传输，实现了RandomAccess接口，支持快速随机访问，实际上就是通过下标序号进行快速访问，实现了Cloneable接口，能被克隆。
- 由于是数组结构，所以ArrayList具有增删慢，查找快的特点。
Java中ArrayList和LinkedList区别
1.ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。
2.对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。
3.对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据
Serializable作用？
想把的内存中的对象状态保存到一个文件中或者数据库中时候
想把对象通过网络进行传播的时候
CopyOnWriteArrayList
1、初始化
/**
* Creates an empty list.
* 创建了一个大小为0的Object数据作为array的初始值
*/
public CopyOnWriteArrayList() {
setArray(new Object[0]);
}
public CopyOnWriteArrayList(E[] toCopyIn) {
setArray(Arrays.copyOf(toCopyIn, toCopyIn.length, Object[].class));
}
public CopyOnWriteArrayList(Collection<? extends E> c) {
Object[] elements;
if (c.getClass() == CopyOnWriteArrayList.class)
elements = ((CopyOnWriteArrayList<?>)c).getArray();
else {
elements = c.toArray();
// c.toArray might (incorrectly) not return Object[] (see 6260652)
if (elements.getClass() != Object[].class)
elements = Arrays.copyOf(elements, elements.length, Object[].class);
}
setArray(elements);
}
2、add(E e)
public boolean add(E e) {
//加独占锁（1）
final ReentrantLock lock = this.lock;
lock.lock();
try {
//获取array(2)
Object[] elements = getArray();
//拷贝array到新数组，添加元素到新数组(3)
int len = elements.length;
Object[] newElements = Arrays.copyOf(elements, len + 1);
newElements[len] = e;
//使用新数组替换添加前的数组(4)
setArray(newElements);
return true;
} finally {
//释放独占锁(5)
lock.unlock();
}
}
首先，调用add方法的线程会首先执行代码去获取独占锁，只有一个线程获取到该锁，其余线程阻塞，保证数据的唯一。
然后，获取锁后执行getArray()方法获取array，然后拷贝array到一个新数组（大小是原来数组+1，所以数组容量是无届的），并把要新加的元素添加到新数组中。
最后，把新数组替换原数组，然后返回前要释放锁，由于加了锁，所以整个add过程是个原子操作，需要注意的是添加元素时候首先是拷贝了一个快照，然后在快照上进行的添加，而不是直接在源来的数组上进行。
3、get(int index)
public E get(int index) {
return get(getArray(), index);
}
final Object[] getArray() {
return array;
}
private E get(Object[] a, int index) {
// 形参直接指向了原数组，array引用地址的改变并不影响这里取值
return (E) a[index];
}
}
首先获取到当前list里面的array数组，然后通过随机访问的下标方式访问指定位置的元素。
从代码中可以看到整个过程并没有加锁，这就可能会导致当执行完步骤1后执行步骤2前，另外一个线程Y进行了修改操作，比如remove操作，就会进行写时拷贝删除当前get方法要访问的元素，并且修改当前list的array为新数组。
在线程x执行get操作的时候并不是直接通过全局array访问数组元素而是通过方法的形参a访问的，a指向的地址和array指向的地址在调用get方法的那一刻是一样的，都指向了堆内存的数组对象。之后改变array指向的地址并不影响get的访问，因为在调用get方法的那一刻形参a指向的内存地址就已经确定了，不会改变。
所以，虽然线程y已经删除了index处的元素但是线程x的获取操作还是会返回index处的元素。
3、set(int index, E element)
public E set(int index, E element) {
final ReentrantLock lock = this.lock;
lock.lock();
try {
Object[] elements = getArray();
E oldValue = get(elements, index);
if (oldValue != element) {
int len = elements.length;
Object[] newElements = Arrays.copyOf(elements, len);
newElements[index] = element;
setArray(newElements);
} else {
// Not quite a no-op; ensures volatile write semantics
setArray(elements);
}
return oldValue;
} finally {
lock.unlock();
}
}
首先获取了独占锁控制了其他线程对array数组的修改，然后获取当前数组，并调用get方法获取指定位置元素。
如果指定的位置元素与新值不一致则创建新数组并拷贝元素，在新数组上修改指定位置元素值并设置新数组到array。
如果指定位置元素与新值一样，则为了保障volatile语义，还是需要重新设置下array，虽然array内容并没有改变(为了保证 volatile 语义是考虑到 set 方法本身应该提供 volatile 的语义）
4、删除元素
public E remove(int index) {
//获取独占锁
final ReentrantLock lock = this.lock;
lock.lock();
try {
//获取数组
Object[] elements = getArray();
int len = elements.length;
//获取指定元素
E oldValue = get(elements, index);
int numMoved = len - index - 1;
//如果要删除的是最后一个元素
if (numMoved == 0)
setArray(Arrays.copyOf(elements, len - 1));
else {
//分两次拷贝除删除后的元素到新数组
Object[] newElements = new Object[len - 1];
System.arraycopy(elements, 0, newElements, 0, index);
System.arraycopy(elements, index + 1, newElements, index,
numMoved);
//使用新数组代替老的
setArray(newElements);
}
return oldValue;
} finally {
//释放锁
lock.unlock();
}
}
首先是获取独占锁保证删除数组期间，其他线程不能对array进行修改，然后获取数组中要给删除的元素，并把剩余的原始拷贝到新数组后，把新数组替换原来的数组，最后在返回前释放锁。
弱一致性
import java.util.Iterator;
import java.util.concurrent.CopyOnWriteArrayList;
/**
* Created by cong on 2018/6/9.
*/
public class CopyOnWriteArrayListTest {
private static volatile CopyOnWriteArrayList<String> arrayList = new CopyOnWriteArrayList<>();
public static void main( String[] args ) throws InterruptedException
{
arrayList.add("hello");
arrayList.add("Java");
arrayList.add("welcome");
arrayList.add("to");
arrayList.add("hangzhou");
Thread threadOne = new Thread(new Runnable() {
@Override
public void run() {
//修改list中下标为1的元素为JavaSe
arrayList.set(1, "JavaSe");
//删除元素
arrayList.remove(2);
arrayList.remove(3);
}
});
//保证在修改线程启动前获取迭代器
Iterator<String> itr = arrayList.iterator();
//启动线程
threadOne.start();
//等在子线程执行完毕
threadOne.join();
//迭代元素
while(itr.hasNext()){
System.out.println(itr.next());
}
}
}
打印的结果来看，子线程里面进行的操纵是一个都没有生效，这就是迭代器的弱一致性的效果，需要注意的是获取迭代器必须在子线程操作之前进行。
注意：CopyOnWriteArrayList使用写时拷贝的策略来保证list的一致性，而获取-拷贝-写入 三步并不是原子性的，所以在修改增删改的过程中都是用了独占锁，并保证了同时只有一个线程才能对list数组进行修改。
另外CopyOnWriteArrayList提供了弱一致性的迭代器，保证在获取迭代器后，其他线程对list的修改该不可见，迭代器遍历时候的数组是获取迭代器时候的一个快照。
HashMap
HashMap实际上是一个“链表散列”的数据结构;
HashMap中存在键为NULL的键值对，那么一定在第一个桶中。
重写 equals 和 hash 方法
@Override
public boolean equals(Object o) {
//自反性
if (this == o) return true;
//任何对象不等于null，比较是否为同一类型
if (!(o instanceof Person)) return false;
//强制类型转换
Person person = (Person) o;
//比较属性值
return getId() == person.getId() &&
Objects.equals(getName(), person.getName()) &&
Objects.equals(getSex(), person.getSex());
}
@Override
public int hashCode() {
return Objects.hash(getId(), getName(), getSex());
}
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
// 右移16位之后和自身与运算，相当于自己的高半区和低半区做异或,加大低位的随机性
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
// hashCode和数组长度-1进行与运算
static int indexFor(int h, int length) {
return h & (length-1);
}
扫一扫
302
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
