前言集合只能存储对象,存放的是多个对象的引用,对象本身还是放在堆内存中。
Collections和Arrays工具类:
两个工具类分别操作集合和数组,可以进行常用的排序,合并等操作。
TreeMap和TreeSet:
主要是基于红黑树实现的两个数据结构,可以保证key序列是有序的。
HashMap和HashSet:
基于哈希表实现,支持快速查找。
ArrayList(有序列表,允许存放重复的元素,允许使用null元素)接口:
List
实现类:
LinkedList,Vector,ArrayList:
ArrayList:数组实现,查询快,增删慢,轻量级(线程不安全)
LinkedList:双向链表实现,增删快,查询慢,轻量级(线程不安全)
Vector:数组实现,重量级(线程安全、使用少)
ArrayList是实现List接口的动态数组。
同步访问:List list = Collections.synchronizedList(new ArrayList(...));
ArrayList:
继承:
AbstractList抽象父类
实现:
List接口(规定了List的操作规范)
RandomAccess(可随机访问)
Cloneable(可拷贝)
Serializable(可序列化)
ArrayList:
优点:
get(int index) set(int index, E element)与顺序添加( add(E e) )非常快。时间复杂度O(1)
缺点:
插入删除( add(int index, E element) 和 remove(int index) )非常慢,因为涉及元素复制。时间复杂度O(n)
public class ArrayList
extends AbstractList
implements List, RandomAccess, Cloneable, java.io.Serializable
Vector大部分方法都使用了synchronized修饰符,所以他是线层安全的集合类。
public class Vector extends AbstractList implements List, RandomAccess, Cloneable, java.io.Serializable
public class Stack extends Vector
LinkedList(有序列表,允许存放重复的元素,允许使用null元素)LinkedList是采用双向循环链表实现的:
利用LinkedList实现栈(stack)、队列(queue)、双向队列(double-ended queue)。
它具有方法addFirst()、addLast()、getFirst()、getLast()、removeFirst()、removeLast()等。
public class LinkedList
extends AbstractSequentialList
implements List, Deque, Cloneable, java.io.Serializable
LinkedList在插入和删除时更优于ArrayList,而随机访问则比ArrayList差。
Set(不允许存放重复的元素,允许使用null元素)接口:Set
实现类:HashSet (无序,查找时间复杂度为O(1) )、LinkedHashSet(有序)
Set的子接口:SortedSet
实现类:TreeSet (排序, 查找时间复杂度O(logN) )
HashSet常用方法:
public boolean contains(Object o); //如果set包含指定元素,返回true
HashSet需要同时通过equals和HashCode来判断两个元素是否相等:
具体规则是,如果两个元素通过equals为true,并且两个元素的hashCode相等,则这两个元素相等(即重复)。
LinkedHashSet本质上也是从LinkedHashMap而来:
LinkedHashSet的所有方法都继承自HashSet, 而它能维持元素的插入顺序的性质则继承自LinkedHashMap。
TreeSet(只允许存入同一类的元素):
TreeSet的排序分两种类型,一种是自然排序,另一种是定制排序:
自然排序(在元素中写排序规则):
TreeSet 会调用compareTo()方法比较元素大小,然后按升序排序。所以自然排序中的元素对象,都必须实现了Comparable接口
定制排序(在集合中写排序规则)
TreeSet 还有一种排序就是定制排序,定制排序时候,需要关联一个 Comparator对象。
总结:
HashSet 的元素存放顺序和我们添加进去时候的顺序没有任何关系。
LinkedHashSet 则保持元素的添加顺序。
TreeSet 则是对我们的Set中的元素进行排序存放。
Map(关键字唯一,允许使用null元素)实现类:
HashMap、TreeMap、LinkedHashMap、Hashtable
HashMap:
键值对,key不能重复,但是value可以重复,允许null的键或值。
Hashtable:
线程安全的,不允许null的键或值。
Properties:
key和value都是String类型,用来读配置文件。
TreeMap:
对key排好序的Map。key要实现Comparable接口或TreeMap有自己的构造器。
LinkedHashMap:
此实现与 HashMap 的不同之处在于,后者维护着一个运行于所有条目的双重链接列表。存储的数据是有序的。
HashMap实现原理:散列
如果负载因子0.75,当散列表中已经有75%位置已经放满,那么将进行再散列。
负载因子越高(越接近1.0),内存的使用效率越高,元素的寻找时间越长。
负载因子越低(越接近0.0),元素的寻找时间越短,内存浪费越多。
Map集合比较:
HashMap 无序。
LinkedHashMap 保留了键值对的存入顺序。
TreeMap 则是对Map中的元素进行排序。
HashMap 和 LinkedHashMap 存储数据的速度比直接使用TreeMap 要快,存取效率要高。
注意:TreeMap中是根据键(Key)进行排序的。
而如果我们要使用TreeMap来进行正常的排序的话,Key中存放的对象必须实现Comparable接口。
Map常用方法:
boolean containsKey(Object key) :判断Map中是否存在某键(key)
boolean containsValue(Object value) :判断Map中是否存在某值(value)
public Set keySet() :返回所有的键(key),并使用Set容器存放
public Collection values() :返回所有的值(Value),并使用Collection存放
public Set> entrySet(); :返回一个实现 Map.Entry 接口的元素 Set
Queuepublic interface Queue extends Collection {}
PriorityQueue:底层用数组实现堆的结构
public class PriorityQueue
extends AbstractQueue
implements java.io.Serializable
PriorityQueue不是一个线程安全的类:
如果要在多线程环境下使用,可以使用 PriorityBlockingQueue 这个优先阻塞队列。
其中add、poll、remove方法都使用 ReentrantLock 锁来保持同步,take() 方法中如果元素为空,则会一直保持阻塞。
Dequepublic interface Deque extends Queue {}
ArrayDeque:底层使用循环数组实现双向队列
public class ArrayDeque
extends AbstractCollection
implements Deque, Cloneable, Serializable {
transient Object[] elements;
transient int head;
transient int tail;
}
IteratorIterator iterator = list.iterator();
while(iterator.hasNext()){
String string = iterator.next();
do something;
}
public interface Iterator {
boolean hasNext();
E next();
default void remove() {throw new UnsupportedOperationException("remove");}
}
public class ArrayList {
public Iterator iterator() {return new Itr();}
private class Itr implements Iterator {
int cursor; // index of next element to return
int lastRet = -1; // index of last element returned; -1 if no such
int expectedModCount = modCount;
}
}
迭代器模式提供一个对象来顺序访问聚合对象中的一系列数据,而不暴露聚合对象的内部表示。
// 抽象迭代器
interface Iteratoring {
public boolean hasNext();
public Object next();
}
//具体迭代器
class ConcreteIterator implements Iteratoring {
private ArrayList li;
public ConcreteIterator(ArrayList li) {
this.li = li;
}
int count = 0;
@Override
public boolean hasNext() {
if (count < li.size()) {
return true;
}
return false;
}
@Override
public Object next() {
if (hasNext()) {
return li.get(count++);
}
return null;
}
}
//抽象聚合
interface Aggregate {
public void add(Object obj);
public void remove(Object obj);
public Iteratoring getIterator();
}
//具体聚合
class ConcreteAggregate implements Aggregate {
private ArrayList arr = new ArrayList();
@Override
public void add(Object obj) {
arr.add(obj);
}
@Override
public void remove(Object obj) {
arr.remove(obj);
}
@Override
public Iteratoring getIterator() {
return new ConcreteIterator(arr);
}
}
Comparable(内比较器,耦合强) 和 Comparator(外比较器)public interface Comparable {
public int compareTo(T o); //自然比较方法
}
public class Girl implements Comparable { //可以用Collections.sort() 或者 Arrays.sort() 进行排序
public int compareTo(Object o) {
Girl g = (Girl)o;
return this.age - g.getAge();
}
}
public interface Comparator {
int compare(T o1, T o2);
boolean equals(Object obj);
default Comparator reversed() {
return Collections.reverseOrder(this);
}
}
Comparator byName = (User o1, User o2) -> o1.getName().compareTo(o2.getName());
list.sort((User o1,User o2) -> o1.getAge() - o2.getAge());
Fail-Fast 机制对应非线程安全的数据结构,使用迭代器在发生线程不安全的操作时会报错。
实现通过 modCount 域(修改次数),对ArrayList 内容的修改都将增加这个值,
那么在迭代器初始化过程中会将这个值赋给迭代器的 expectedModCount。
在迭代过程中,判断 modCount 跟 expectedModCount 是否相等,如果不相等就表示已经有其他线程修改了 ArrayList。
因此,遍历那些非线程安全的数据结构时,尽量使用迭代器
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
asList() 与 subList() 的缺陷8个基本类型是无法作为asList的参数的,要想作为泛型参数就必须使用其所对应的包装类型。
asList产生的列表不可操作。
subList()返回的只是原列表的一个视图,它所有的操作最终都会作用在原列表上。
对于子列表视图,它是动态生成的,生成之后就不要操作原列表了,否则必然都导致视图的不稳定而抛出异常。
最好的办法就是将原列表设置为只读状态,要操作就操作子列表。
删除100-200位置处的数据:
list.subList(100, 200).clear();