常用集合类
List ArrayList -- 自动扩容的数组,有序可重复
LinkedList -- 双向链表,有序(存取的先后顺序)可重复,随机添加删除元素效率较高
Set HashSet -- 源码使用HashMa实现,无序不可重复,添加取元素不保证有序
Treeset -- 源码使用TreeMap实现,不重复,按照一定规则进行排序
Map HashMap -- 底层是散列表(哈希表),数组+单向列表/红黑树
TreeMap -- 底层是红黑树,无序不可重复
ArrayList
初始化容量为10,自动扩容数组,扩为原先容量的1.5倍,
实例化数组时,默认创建一个长度为10的数组,增加元素其实也就是修改元素值,添加元素时会判断元素个数是否等于数组长度,相等时则会创建一个比原来长度大1.5倍的新数组,然后把原数组的元素复制到新数组,再进行添加,不相等时则直接将值放进数组中。
public void add(Object o) {
int length = elements.length;
if (size == length) {
int newLength = size + (size >> 1);
Object[] newEmts = new Object[newLength];
System.arraycopy(elements, 0, newEmts, 0, length);
elements = newEmts;
}
elements[size++] = o;
}
LinkedList
双向链表,有一个名字为Node的内部类,如下
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;
}
}
当添加元素时,会判断是否已经有数据了,通过成员变量的值是否为null来判断,没有元素(为null时)会创建一个节点,并将第一个和最后一个的成员变量都指向这个节点,如果有,则创建一个新的节点对象,将其的next属性或者prev属性指向变量值last,或者first变量值,然后将first或last的值指向这个新创建的节点。
final Node<E> f = first;
final Node<E> newNode = new Node<>(null, e, f);
first = newNode;
if (f == null)
last = newNode;
else
f.prev = newNode;
size++;
modCount++;
HashSet / HashMap
HashSet的构造方法都会创建HashMap对象,但是只保存key,随便传一个数给value;所以HashSet是不可重复的。
HashMap的entrySet()方法会将键值对封装成一个对象,并返回Set类型的值。
底层是散列表,根据传入的key得到hash值,然后找到数组下标,判断当前位置是否有元素,没有则添加进当前元素,有则比较key与hash值是否都相同,相同则改变value值,不同则看其的next是否为空,不为null则继续比较值,相同则改变值,不同则,比较下一个元素,循环上述操作。
下面是HashMap的添加元素的源代码,当链表长度大于8时,数组长度大于64,会将链表转换成红黑树,否则红黑树转为列表。
final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
tab为Node类型的数组,p,结点对象,n,数组长度,i,下标
Node<K,V>[] tab; Node<K,V> p; int n, i;
当tab为null或长度为0时,表示数组为空
if ((tab = table) == null || (n = tab.length) == 0)
将创建数组并赋值给tab,并将创建的数组长度赋值给n
n = (tab = resize()).length;
//根据hash值得到数组下标,并判断当前位置是否有元素
if ((p = tab[i = (n - 1) & hash]) == null)
没有元素,则将创建一个节点对象并放到此位置
tab[i] = newNode(hash, key, value, null);
//这种情况是当前位置有元素,p是当前元素
else {
//e表示的是节点对象,k是节点对象的key属性
Node<K,V> e; K k;
//判断当前元素的key和hash值是否与传进来的相同
//相同则将当前位置元素赋值给e
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) {
//将当前位置元素指向的下一个元素对象赋值给e,并判断是否为null
if ((e = p.next) == null) {
//空则表示p没有下一个元素,当前链表只有一个元素
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);//树化
break;
}
//如果hash和key一样,结束循环,当前e为下一元素
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
//下一元素既不是空,hash和key又不相同,测将下一元素赋值给p,再次进行循环,比较下一个元素的下一个元素
p = e;
}
}
//当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;
}
TreeSet / TreeMap
底层是红黑树
红黑树(自平衡二叉树)为了解决二叉查找树的缺陷(某一枝条太长,而逐渐变成线性结构,效率低)而生
红黑树,添加元素时,先判断树是否为空,空就直接创建一个树节点, 如果不为空就是有数据,再用循环比较器比较新添加的元素与集合中的元素,知道元素为null时就存进去,大的放右子节点,小的放左子节点,并进行旋转变色操作。
比较器Comparable与Comparator
集合进行排序时,会调用集合中元素的comparableTo()方法,根据其返回值进行排序,返回值小于0,则前排,大于0则后排,等于0则不排
class SuiBian implements Comparable<SuiBian> {
@Override
public int compareTo(Per o) {
return o.age - this.age == 0 ? 0 : o.age - this.age;
}
comparator比较器,用于原类没实现Compatable接口并重写方法,或者原类的排序规则不符合需求时,comparator优先级大于comparable,所以能用comparable比较器,就不要用comparator,因为这样写扩展性高。
TreeSet ts1 = new TreeSet(new NoSComparator());//main方法中
class NoSComparator implements Comparator {//创建一个第三方选择器
@Override
public int compare(Object o1, Object o2) {
if (o1 instanceof NoS && o2 instanceof NoS) {
// 要添加的元素
NoS n1 = (NoS) o1;
// 集合里的元素
NoS n2 = (NoS) o2;
return n1.count - n2.count == 0 ? 0 : (n1.count - n2.count);
}
return 0;
}}
一般采用下面这种方法进行Comparator编写
TreeSet ts1 = new TreeSet(new Comparator() {
@Override
public int compare(Object o1, Object o2) {
if (o1 instanceof NoS && o2 instanceof NoS) {
NoS n1 = (NoS) o1;
NoS n2 = (NoS) o2;
return n1.count - n2.count == 0 ? 0 : (n1.count - n2.count);
}
return 0;
}});
泛型
参数化类型(可以添加任何类型的数据),将所操作的元素的数据类型当作参数,当没有传入泛型实参时,则默认是Object类型,当传入实参时(不能传入基本数据类型,只能传入引用数据类型),会限制元素类型的操作,所操作的数据元素只能是这个数据类型的,并且这样数据一致,不需要进行强转操作。比如ArrayList类,HashMap类