List:
ArrayList
首先我们来看看jdk的ArrayList的add方法的源码是如何实现的:
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
在AarryList类有如下数组的定义
/**
* The array buffer into which the elements of the ArrayList are stored. --这是个存储ArrayList元素的数组
* The capacity of the ArrayList is the length of this array buffer. ---ArrayList的长度即是数组的长度
*/
private transient Object[] elementData;
综上所看,ArrayList底层存储的实现是通过一个数组来实现的
LinkedList
上源码:
/**
* Pointer to first node.
* Invariant: (first == null && last == null) ||
* (first.prev == null && first.item != null)
*/
transient Node<E> first;
/**
* Pointer to last node.
* Invariant: (first == null && last == null) ||
* (last.next == null && last.item != null)
*/
transient Node<E> last;
/**
* Links e as last element.
*/
void linkLast(E e) {
final Node<E> l = last;
final Node<E> newNode = new Node<>(l, e, null);
last = newNode;
if (l == null)
first = newNode;
else
l.next = newNode;
size++;
modCount++;
}
//在ArrayList内部是有这么一个作为"节点"的内部类的
private static class Node<E> {
E item;
Node<E> next;
Node<E> prev;
Node(Node<E> prev, E element, Node<E> next) {
this.item = element;
this.next = next;
this.prev = prev;
}
}
个人理解:至此可以猜测到LinkedList底层实现是链表;这里代码只是列举了往集合末尾添加元素的情况，具体看linkLast(E e)这个方法
linkLast方法内会根据参数e生成Node,再根据tail具体情况，修改生成node的pre/next指向，存储形式也就是链表啦
Map:
map的底层实现是 数组+链表
描述一下map存储key-value的过程:
key和value两个对象put到map的时候，会被封装成Entry<K,V>实体对象；put过程会根据K值生成一个hash码值(int类型,不同的key可能会生成相同的hash码)
这个hash码会被当成数组的索引/下标(index)，数组的每个下标对应一个hash码，而一个hash码对应一个链表(链表存储着具有相同hash码的对象)
比如: 现在要 map.put("aa","123"); "aa"对应的hash码是121
map.put("bb","123"); "bb"对应的hash码也是121 执行put操作的时候程序会先到数组找到下标为121(也就是hash的数值)的链表，再通过链表存储put进来的对象
具体代码:
/**
* Associates the specified value with the specified key in this map.
* If the map previously contained a mapping for the key, the old
* value is replaced.
*
* @param key key with which the specified value is to be associated
* @param value value to be associated with the specified key
* @return the previous value associated with <tt>key</tt>, or
* <tt>null</tt> if there was no mapping for <tt>key</tt>.
* (A <tt>null</tt> return can also indicate that the map
* previously associated <tt>null</tt> with <tt>key</tt>.)
*/
public V put(K key, V value) {
if (key == null)
return putForNullKey(value);
int hash = hash(key.hashCode());
int i = indexFor(hash, table.length); //找出数组对应的下标
for (Entry<K,V> e = table[i]; e != null; e = e.next) { //找到数组内对应下标的链表对象
Object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) { //原先key已经存在时，覆盖操作
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++;
addEntry(hash, key, value, i);//原先不存在key对应的Entry则在链表后添加
return null;
}
Set
set的特点是无序，不重复
// Dummy value to associate with an Object in the backing Map
private static final Object PRESENT = new Object();
public boolean add(E e) {
return map.put(e, PRESENT)==null;
}
以上是HashSet源码，可以看出HashSet底层是通过Map来实现的，不重复实现:e的hash值相同时,Map会采取覆盖的形式，这样就不会有重复了
Map的无序也就自然导致了HashSet的无序了(hash值求法?HashCode与equals)
"打完收工"....