《疯狂Java讲义》学习笔记（七）Java集合

1、Java集合概述

• 为了保存数量不确定的数据，以及保存具有映射关系的数据（关联数据），Java提供了集合类。Java集合大致可分为Set、List、Queue和Map四种体系，其中Set代表无序、不可重复的集合；List代表有序、重复的集合；Map代表具有映射关系的集合；Queue代表一种队列集合实现
• 集合类和数组不同，数组元素既可以是基本类型的值，也可以是对象；而集合里只能保存对象，两者实际保存的是对象的引用变量。
• Java的集合类主要由两个接口派生：Collection和Map，两者是Java集合框架的根接口，这两个接口又包含了一些子接口或实现类
• Collection和Map的继承树
  四种集合最常用的实现类为HashSet、TreeSet、ArrayList、ArrayDeque、LinkedList、HashMap和TreeMap等实现类。

2、Collection和Iterator接口

• Collection接口是List、Set和Queue的父接口，该接口定义的方法三种集合都可用：

boolean add(Object o)：往集合里添加一个元素，添加成功返回true
boolean addAll(Collection c)：把集合c里的所有元素添加到指定集合里，添加成功返回true
void clear()：清除集合里的所有元素，将集合长度变为0
boolean contains(Object o)：集合里是否包含指定元素
boolean containsAll(Collection c)：集合里是否包含集合c里的所有元素
boolean isEmpty()：集合是否为空，当长度为0时返回true
Iterator iterator()：返回一个Iterator对象，用于遍历集合里的元素
boolean remove(Object o)：删除集合中的指定元素，当集合包含多个元素o时，只删除第一个符合的元素并返回true
boolean removeAll(Collection c)：从集合中删除集合c里包含的所有元素（该集合减去集合c），如果删除一个或以上的元素返回true
boolean retainAll(Collection c)：从集合中删除集合c里不包含的元素（交集），操作成功返回true
int size()：返回集合里元素的个数
Object[] toArray()：把集合转换成一个数组

• Lambda表达式遍历集合
  Java8为Iterable（Collection的父接口）接口新增了一个forEach(Consumer action)默认方法

new List<String>().forEach(obj->System.out.println(obj));

• Java8增强的Iterator遍历集合元素

boolean hasNext()：如果被迭代的集合元素还未被遍历完，返回true
Object next()：返回集合里的下一个元素
void remove()：删除集合里上一次next方法返回的元素
void forEachRemaining(Consumer action)：可以使用Lambda表达式来遍历集合元素
List<Student> stuList = new ArrayList<Student>();
stuList.add(new Student("tom",20));
stuList.add(new Student("jack",22));
stuList.forEach(obj->System.out.println(obj.getName()+"\n"+obj.getAge()));
Iterator<Student> iter = stuList.iterator();
iter.forEachRemaining(obj->System.out.println(obj.getName()+"\n"+obj.getAge()));
Iterator必须依附于Collection对象，若有一个Iterator对象，则必然有一个与之关联的Collection对象

• Java8新增的Predicate操作集合

removelf(Predicate filter)可以批量删除符合filter条件的所有元素
stuList.removeIf(obj->obj.getName().equals("tom"));

• Java8新增的Stream操作集合

stuList.stream().filter(ele->(ele.getAge()>10)).count();
常用API：
filter(Predicate predicate)：过滤Stream中所有不符合predicate的元素
distinct()：用于排序流中所有重复的元素，调用equals()比较
sorted()：排序
forEach(Consumer action)：遍历元素
toArray()
min()
max()
count()
anyMatch(Predicate predicate)：判断流中是否至少包含一个元素符合predicate条件
allMatch()：判断流中是否每个元素都符合predicate条件
noneMatch()：判断流中是否所有元素都不符合predicate条件
findFirst()：返回流中的第一个元素
findAny()：返回流中的任意一个元素

2、Set集合

• HashSet类
  该类按Hash算法来存储集合中的元素，因此具有很好的存取和查找性能
  HashSet不能保证元素的排列顺序，顺序可能与添加顺序不同，也可能发生变化
  HashSet不是同步的，如果多线程同时访问一个HashSet，则必须通过代码来保证其同步
  HashSet元素值可以是null
  HashSet判断两个元素相等的标准是equal()方法和hashCode()方法同时都相等
  如果两个对象通过equals()方法比较返回true，则这两个对象的hashCode值也应该相同
• LinkedHashSet
  LinkedHashSet是HashSet的子类，也是根据元素的hashCode值来决定元素存储位置，但它同时使用链表维护元素的次序，使得元素看起来是以插入的顺序保存，由于需要维护插入顺序，因此性能略低于HashSet
• TreeSet

TreeSet是SortedSet接口的实现类，可以确保集合元素处于排序状态
常用API：
Comparator comparator()：如果TreeSet采用了定制排序，则返回定制排序所使用的Comparator；如果采用了自然排序，返回null
Object first()：返回第一个元素
Object last()：返回最后一个元素
Object lower(Object e)：返回小于指定元素的一个元素
Object higher(object e)：返回大于指定元素的一个元素
SortedSet subSet(Object fromElement,Object toElement)：返回Set子集，范围从fromElement（包含）到toElement（不包含）
SortedSet headSet(Object toElement)：返回小于toElement元素的Set子集
SortedSet tailSet(Object fromElement)：返回大于或等于fromElement元素的Set子集
定制排序：
TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
    @Override
    public int compare(Student o1, Student o2) {
        return o1.getAge() - o2.getAge();
    }
});
TreeSet<Student> ts = new TreeSet<Student>((o1,o2)->{
    return o1.getAge()-o2.getAge();
});

• EnumSet类

EnumSet是一个专为枚举类设计的集合类，所有元素必须都是指定的枚举类型的枚举值
EnumSet在内部以位向量的形式存储，非常搞笑
EnumSet不允许加入null元素
// 输出[SPRING,SUMMER,FALL,WINTER]
EnumSet<Season> es1 = EnumSet.allOf(Season.class);
// 输出[]
EnumSet<Season> es2 = EnumSet.noneOf(Season.class);
es2.add(Season.WINTER);
es2.add(Season.SPRING);
// 输出[SPRING,WINTER]
System.out.println(es2);
// 输出[SUMMER,WINTER]
EnumSet<Season> es3 = EnumSet.of(Season.SUMMER,Season.WINTER);
// 输出[SUMMER,FALL,WINTER]
EnumSet<Season> es4 = EnumSet.range(Season.SUMMER,Season.WINTER);
// 输出[SPRING]，es4 + es5 = Season枚举类的全部枚举值
EnumSet<Season> es5 = EnumSet.complementOf(es4);

• Set实现类的性能分析
  EnumSet>HashSet> LinkedHashSet
  三个类都非线程安全，可以通过Collections工具类的synchronizedSortedSet方法来实现线程同步

3、List集合

• List常用API

void add(int index,Object element)：将元素插入到List集合的index处
boolean addAll(int index,Collection c)：将集合所包含的所有元素插入到List集合的index处
Object get(int index)：返回集合index索引处的元素
int indexOf(Object o)：返回对象在List集合中第一次出现的位置索引
int lastIndexOf(Object o)：返回对象在List集合中最后一次出现的位置索引
Object remove(int index)：删除并返回index索引处的元素
Object set(int index,Object element)：将index索引处的元素替换成element对象，返回被替换的旧元素
List subList(int fromIndex,int toIndex)：返回从索引fromIndex（包含）到索引toIndex（不包含）处所有集合元素组成子集合
Java8：
void replaceAll(UnaryOperator operator)：根据operator指定的计算规则重新设置List集合的所有元素
strList.replaceAll(ele->ele.length()+"")//使用每个字符串的长度作为新的集合元素
void sort(Comparator c)：根据Comparator参数对List集合的元素排序
studentList.sort((o1,o2)->(o1.age-o2.age))

• 相比Set，List额外提供了一个listIterator()方法，增加了向前迭代

boolean hasPrevious()：是否还有上一元素
Object previous()：返回上一个元素
void add(Object o)：在指定位置插入一个元素，在迭代过程中可以使用该方法向上一次迭代元素的后面添加一个新元素
- ArrayList和Vector实现类
如果一开始就知道集合需要保存多少个元素，可以在创建的时候就指定initialCapacity大小，否则默认长度为10
void ensureCapacity(int minCapacity)：将ArrayList或Vector集合的Object[]数组长度增加大于或等于minCapacity值
void trimToSize()：调整ArrayList或Vector集合的Object[]数组长度为当前元素的个数，可以减少集合对象占用的存储空间
ArrayList和Vector在用法上基本相同，但Vector比较古老，一般尽量减少使用
ArrayList是线程不安全的，Vector是线程安全的
Vector提供了一个Stack子类，模拟栈数据，但比较古老，可以用ArrayDeque替代

• 固定长度的List

可以使用Arrays.asList(Object... a)方法将数组或指定个数的对象转换成List，但这个List不是ArrayList或Vector实现类的集合，而是Arrays的内部类ArrayList的实例，所以程序只能遍历访问集合里的元素，不可增加、删除该集合里的元素

4、Queue集合

Queue用于模拟队列数据结构，队列通常是指“先进先出”（FIFO）的容器，通常不允许随机访问队列中的元素
- Queue的常用API

void add(Object e)：将指定元素加入到队列的尾部
Object element()：获取队列头部元素，但不删除该元素
boolean offer(Object e)：和add基本相同，当使用有容量限制的队列时，此方法会更好
Object peek()：获取队列头部的元素，但不删除该元素
Object poll()：获取队列头部的元素，并删除该元素
Object remove()：获取队列头部的元素，并删除该元素

• PriorityQueue实现类

PriorityQueue保存队列元素的顺序并不是按加入队列的顺序，而是按队列元素的大小进行重新排序，因此不是标准的队列实现类
PriorityQueue不允许插入null元素，有两种排序：
自然排序：队列中的元素必须实现了Comparable接口
定制排序：创建时传入一个Comparator对象，匿名内部类实现逻辑
- Deque接口
Deque接口是Queue接口的子接口，它代表一个双端队列：
void addFirst(Object e)
void addList(object e)
Iterator descendingIterator()
Object getFirst()
Object getLast()
boolean offerFirst(Object e)
boolean offerLast(Object e)
Object peekFirst()
Object peekLast()
Object pollFirst()
Object pollLast()
Object pop()
void push(Object e)
Object removeFirst()
Object removeFirstOccurence(Object o)
Object removeLast()
Object removeLastOccurence(Object o)
Deque不仅可以当成双端队列使用，而且可以被当成栈来使用，该类包含了pop（出栈）和push（入栈）两个方法

• ArrayDeque实现类

ArrayDeque是一个基于数组实现的双端队列
模拟栈：
ArrayDeque<Integer> stack = new ArrayDeque<Integer>();
stack.push(1);
stack.push(2);
stack.push(3);
// 3
System.out.println(stack.peek());
// 3
System.out.println(stack.pop());
// [2, 1]
System.out.println(stack);
- LinkedList实现类
LinkedList是List和Deque的实现类，它是一个List集合，可以根据索引来随机访问集合中的元素，也可以被当成双端队列，还可以当成栈来使用
LinkedList<Integer> linkedList = new LinkedList<Integer>();
// 加入到队列的尾部
linkedList.offer(1);
// 加入到栈的顶部
linkedList.push(2);
// 加入到队列的头部
linkedList.offerFirst(3);
System.out.println(linkedList);
// 访问栈顶
System.out.println(linkedList.peekFirst());
// 访问队列最后一个元素
System.out.println(linkedList.peekLast());
// 将栈顶的元素弹出
System.out.println(linkedList.pop());
// 弹出队列最后一个元素
System.out.println(linkedList.pollLast());
LinkedList与ArrayList、ArrayDeque的实现机制完全不同，ArrayList和ArrayDeque内部以数组的形式来保存集合中的元素，随机访问集合元素时有较好的性能；LinkedList内部以链表的形式来保存集合中的

• 各种线性表性能分析
  如果需要遍历List集合元素，对于ArrayList、Vector集合，应该使用随机访问方法get来遍历集合元素，性能更好；对于LinkedList集合，则应采用迭代器Iterator来遍历集合元素
  如果需要经常执行插入、删除操作来改变包含大量数据的List集合的大小，可以考虑使用LinkedList集合
  如果有多个现场需要同时访问List集合中的元素，应考虑使用Collections将集合包装成线程安全的集合

5、Map集合

• Map用于保存具有映射关系的数据，Map集合里保存着两组值，一组值用于保存Map里的key，另一组值用于保存Map里的value，key和value都可以是任何引用类型数据
• key不允许重复，即任何两个key通过equals方法比较总是返回false
• key和value之间存在单向一对一关系，Map中的所有key组成一个Set集合，keySet()方法可以获取，而所有value放在一起看又非常类似一个List，value可以重复，可以根据key来查找
• Map的常用API：

void clear(Object key)：删除该Map对象中的所有key-value对
boolean containsKey(Object value)：查询Map中是否包含指定的key，如果包含则返回true
boolean containsValue(Object value)：查询Map中是否包含一个或多个value，如果包含则返回true
Set entrySet()：返回Map中包含的key-value对所有组成的Set集合，每个集合元素都是Map.Entry（Entry是Map的内部类）对象
Object get(Object key)：返回指定key所对象的value；如果不包含则返回null
boolean isEmpty()：Map是否为空，空则返回true
Set keySet()：所有key组成的Set集合
Object put(Object key,Object value)：添加一个key-value对，如果当前Map中已有一个与该key相等的key-value对，则新的key-value对会覆盖原来的key-value对
void putAll(Map m)：将指定的key-value对复制到本Map中
Object remove(Object key)：删除指定key所对应的key-value对，返回被删除key所关联的value，如果该key不存在，返回null
boolean remove(Object key,Object value)：java8新增的方法，删除指定key和value所对应的key-value对，成功返回true
int size()：返回该Map里的key-value对的个数
Collection values()：返回该Map里所有value组成的Collection

• Map中包括一个内部类Entry，该类封装了一个key-value对：

Object Entry.getKey()
Object Entry.getValue()
Object Entry.setValue(V value)

• Java8新增方法

Object compute(Object key,BiFunction remappingFunction)：根据原来的key-value计算一个新的value值，只要新value不为null，就覆盖原value；如果原value不为null，新的value为null，则删除原key-value对；如果原value、新value同时为null，那么该方法不改变key-value对，返回null
Object computelfAbsent(Object key,Function mappingFunction)：如果Map本来的value是null，则根据key计算一个新结果，新结果不为null则覆盖value；如果找不到key则新增一组键值对
Object computelfPresent(Object key,BiFunction remappingFunction)：如果Map本来的value是null，则根据key、value计算一个新结果，新结果不为null则覆盖value；结果为null则删除原来键值对
void forEach(BiConsumer action)
Object getOrDefault(Object key,V defaultValue)：获取指定key的value，如果该key不存在，则返回defaultValue
Object merge(Object key,Object value,BiFunction remappingFunction)：如果原value为null，则用value覆盖原value，否则根据原value和新value计算一个新结果覆盖原value
Object pulfAbsent(Object key,Object value)：检查原value是否为null，是就覆盖value
Object replace(Object key,Object value)：替换value，如果key不存在，返回null，并不会添加新的键值对
boolean replace(K key,V oldValue,V newValue)：同上
replaceAll(BiFunction function)：根据key-value结算覆盖value值

• HashMap和Hashtable区别：

Hashtable线程安全，HashMap线程不安全所以性能也高一点
Hashtable不允许使用null作为key和value；HashMap可以而且可以有无数个value是null，但key只能有一个是null
为了成功地在HashMap、Hashtable中存储和获取对象，用作key的对象必须实现hashCode()方法和equals方法

• LinkedHashMap实现类

LinkedHashMap使用双向链表来维护key-value对的次序，迭代顺序和插入顺序一致，因此避免了对HashMap、Hashtable进行排序，又能避免使用TreeMap所增加成本

• 使用Properties读写属性文件

Properties类是Hashtable类的子类，可以把Map对象和属性文件关联起来，从而可以把Map对象中的key-value对写入属性文件中。
String getProperty(String key)：获取Properties中指定属性名对应的属性值
String getProperty(String key,String defaultValue)：同上，不存在key值时，则返回默认值
Object setProperty(String key,String value)：设置属性值
void load(InputStream inStream)：从属性文件中加载key-value对，把加载到的追加到Properties中
void store(OutputStream out,String comments)：将Properties中的key-value对输出到指定的属性文件中

• SortedMap接口和TreeMap实现类
  自然排序：对key进行排序
  定制排序：创建TreeMap时，传入一个Comparator对象，对所有key进行排序
• WeakHashMap实现类
  类似HashMap，区别在于引用强弱，HashMap所引用的对象是强引用，即只要在引用就不会被回收；而WeakHashMap则是弱引用，对象被回收后，WeakHashMap会自动删除对应的key-value
• IdentityHashMap实现类
  类似HashMap，区别在于对key的比较，IdentityHashMap当且仅当两个key严格相等时，才认为是相等；而HashMap则只要两个key通过equals方法比较返回true且hashCode值相等即可
• EnumMap实现类
  EnumMap是一个与枚举类一起使用的Map实现，EnumMap中的所有key都必须是单个枚举类的枚举值
  创建EnumMap时必须显式或隐式指定它对应的枚举类
  EnumMap在内部以数组形式保存，所以这种实现形式非常紧凑和高效
  EnumMap根据key的自然顺序来维护key-value对的顺序
  EnumMap不允许使用null作为key，但允许null作为value
• 各种Map实现类的性能分析
  EnumMap>Hashtable>HashMap=WeakHashMap>IdentityHashMap>LinkedHashMap>TreeMap

6、操作集合的工具类：Collections

• 排序

void reverse(List list)：反转指定List集合元素排序顺序
void shuffle(List list)：随机排序
void sort(List list)：自然顺序升序排序
void sort(List list,Comparator c)：根据Comparator产生的顺序排序
void swap(List list,int i,int j)：将指定List集合中的i处元素和j处元素进行交换
void rotate(List list,int distance)：当distance为正数时，将list集合的后distance个元素整体移动到前面；负数则相反

• 查找、替换操作

int binarySearch(List list,Object key)：二分法搜索，前提是保证List中的元素已经处于有序状态
Object max(Collection coll)：根据元素的自然排序，返回最大元素
Object max(Collection coll,Comparator comp)：根据指定排序，返回最大元素
Object min(Collection coll)
Object min(Collection coll,Comparator comp)
void fill(List list,Object obj)：使用指定obj替换所有元素
int frequency(Collection c,Object o)：返回出现次数
int indexOfSubList(List source,List target)：返回子List对象在父List对象最后一次出现的位置索引，没找到则返回-1
boolean replaceAll(List list,Object oldVal,Object newVal)：使用一个新值newVal替换List对象的所有旧值oldVal

• 同步控制

Collections类提供了多个synchronizedXxx()方法实现集合线程同步
Collection c = Collections.synchronizedCollection(new ArrayList());
List list = Collections.synchronizedList(new ArrayList());
Set set = Collections.synchronizedSet(new HashSet());
Map map = Collections.synchronizedMap(new HashMap());

• 设置不可变集合

emptyXxx()：返回一个空的、不可变的集合对象
sigletonXxx()：返回一个质保函指定对象的、不可变的集合对象，可以是List也可以是Map
unmodifiableXxx()：返回指定集合对象的不可变视图，List、Set、SortedSet、Map、SortedMap