1 、单列集合
1.1 单列集合的遍历
① 迭代器遍历（需要实现了Iterable接口的类）
- Iterator单向迭代器
- ListIterator双向迭代器
② 增强for循环遍历
- jdk1.5后出现
- 底层也是一个迭代器
- 迭代器遍历的同时，如果要进行增删，需要需用迭代器提供的方法。如果使用ArrayList引用提供的增删方法，则会出现并发异常。
③普通for遍历
List接口
1.2 ArrayList
- 底层为数组
- 可以添加null，可以重复。
- 扩容机制，以下为官方源码
//开始添加
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
//确保容量足够
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
//elementData长度为0时，设置minCapacity = 10；
private static int calculateCapacity(Object[] elementData, int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}
//判断是否需要扩容
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
//容量不够时，扩容
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);
}
- 无参构造创建，长度为0；有参构造创建，则创建为指定长度；有参与无参后续扩容机制一样。
- 添加元素：
add()方法。 add()方法体内：先调用ensureCapacityInternal(int minCapacity)确保添加的元素能装下，长度为0则会将minCapacity复制为10。- 然后执行到
ensureExplicitCapacity(int minCapacity)方法：
①：modCount++记录集合修改的次数；
②：如果数组elementData的长度不够，就调用grow()进行真正的扩容。否则就可以添加数据了。 - 执行
grow()方法时：
①：真正的扩容开始
②：第一次添加（底层数组elementData的长度为0时），则设置默认长度10，该长度数值在calculateCapacity()方法中已经计算出。
③：第二次及以后，按照1.5倍扩容。
④：调用Arrays.copyOf()实现elementData扩容。
1.3 LinkedList
- 底层为双向链表
Set接口
1.4 HashSet
- 无序
- 不能重复
- 可以为null
- 底层为HaspMap
①：jdk1.8之前：数组+链表
②：jdk1.8之后：数组+链表+红黑树
关于添加元素的底层源码：
public boolean add(E e) {
return map.put(e, PRESENT)==null;
}
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); //返回运算后的哈希值
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
添加步骤：
- 执行到
put()方法里面后，先获取元素的哈希值（hashCode()方法） - 对哈希值进行运算，得出一个索引值，即为要存放在数组中的索引。
- 如果该位置上没有其他元素，则直接存放。如果该位置上有其它元素，则要进行
equals()和==判断两个对象，两者是||关系，如果相等则不添加，如果不相等，则以链表的方式添加。
HashSet扩容和转成红黑树机制（其实底层为HashMap）：
- 如果用的无参构造创建，第一次添加时，table数组扩容到16，此时临界值（
threshold） =16 * 0.75（loadFactory） = 12 - 如果table数组到了临界值就会扩容，变为原来长度的2倍，临界值也会变为2倍。
- 在java8中，如果一条链表的元素个数达到
TREEIFY_THREHOLE（8），并且table数组的长度>=MIN_TREEIFY_CAPACITY（64），就会进行树化（红黑树），否则仍然采用数组扩容。
1.4 TreeSet
- 底层为
TreeMap，所以对于添加时的特性与TreeMap相同。
①：底层数据结构为红黑树 - 不能添加
null，不能重复，添加的元素必须实现Compareable接口，否则添加时会报异常。 - 元素有序，不是存储的顺序，而是按照一定的规则排序。
- 关于创建：
①：空参构造创建public TreeSet()，根据其元素的自然顺序进行排序。
②：有参构造创建public TreeSet(Comparator<? super E> comparator)，根据指定的比较器排序。 - 相同的元素不会添加，传入构造器后则用构造器判断是否相等。比较到相同元素时则会返回先前相同元素的value。
- 在比较是时，根据比较方法的返回值判断是否大小。
底层添加的源码
public V put(K key, V value) {
Entry<K,V> t = root;
if (t == null) {
compare(key, key); // type (and possibly null) check
root = new Entry<>(key, value, null);
size = 1;
modCount++;
return null;
}
int cmp;
Entry<K,V> parent;
// split comparator and comparable paths （断比较路径是comparator还是comparable）
Comparator<? super K> cpr = comparator;
if (cpr != null) {
do {
parent = t;
cmp = cpr.compare(key, t.key);
if (cmp < 0)
t = t.left;
else if (cmp > 0)
t = t.right;
else
return t.setValue(value);
} while (t != null);
}
else {
if (key == null)
throw new NullPointerException();
@SuppressWarnings("unchecked")
Comparable<? super K> k = (Comparable<? super K>) key;
do {
parent = t;
cmp = k.compareTo(t.key);
if (cmp < 0)
t = t.left;
else if (cmp > 0)
t = t.right;
else
return t.setValue(value);
} while (t != null);
}
Entry<K,V> e = new Entry<>(key, value, parent);
if (cmp < 0)
parent.left = e;
else
parent.right = e;
fixAfterInsertion(e);
size++;
modCount++;
return null;
}
2、双列集合
2.1 HashMap
- 键可以为
null。 - 添加重复的键时，第二个会覆盖第一个，返回第一个。
- 非线程安全。
- 遍历
①：public Set<K> keySet()：返回所有key的Set集合，然后根据key获取value。
②：public Set<Map.Entry<K,V>> entrySet()：获取所有的键值对对象（Map.Entry）,以Set集合的形式返回；Entry对象有方法getKey()，getValue() - 底层数据结构：
①：jdk1.8之前：数组+链表
②：jdk1.8之后：数组+链表+红黑树 - 关于扩容和树化，可以参照
HashSet。
2.2Properties
- 表示一个持久的属性集
(1) 属性集：描述的是属性名称和属性值的对应关系，其实还是一个双列集合
(2) 持久：可以操作到流中，也可以从流中获取，可以很方便的和文件进行交互，是Map体系的集合类，Hashtable的子类，所以可以当做普通的map集合来使用，属性列表中的每个键和值都是String类型，因此不需要写泛型 - 主要作用：
(1) 一般是用于配置文件的读写，能将配置文件中的数据，读取到集合中
(2) 配置文件，一般都是键值对的关系(都是String类型)进行存储，因此Properties中默认的键值对类型(String,String) - 配置文件中的注释：使用#
(1) #userName 表示用户姓名
(2) userName=张三
(3) password=1234 - 构造方法，空参构造即可
- 常用方法：
(1) put(K k,V v):将参数中的键值对存储到Properties集合中，继承自父类的方法（一般不会去使用）
(2) setProperty(String val,String val):将键值对映射关系添加到集合中，键和值都是String类型，key值不重复，如果重复，就是替换
(3) getProperty(String key):根据key值获取对应的value值
(4) stringPropertyNames()：将集合中所有的key值获取到，放入一个set集合中
525
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
