第6章 - Java集合

第6章- 集合

 

15 Java集合类(集合框架)

15.1 集合类概述

1.集合类的由来: 

    对象用于封装特有数据, 对象多了需要存储, 如果对象的个数不确定. 就使用集合容器进行存储. 

    Java语言的java.util包中提供了一些集合类, 这些集合类又被称为容器(数组也是个容器)

2.特点: 

    1).用于存储对象的容器

    2).集合的长度是可变的

    3).集合中不可以存储基本数据类型值

3.集合与数组不同之处

    1).数组的长度是固定的, 集合的长度是可变的

    2).数组用来存放基本类型的数据, 集合用来存放对象的引用

    集合容器因为内部的数据结构不同, 有多重具体容器, 不断的向上抽取, 就形成了集合框架

    常见的集合有List集合, Set集合, Map集合, 其中List与Set实现了Collection接口

如图所示:

1).集合接口: 8个接口(短虚线表示), 表示不同集合类型, 是集合框架的基础

    Iterator, ListIterator, Collection, List, Set, Map, SortedSet, SortedMap

2).抽象类: 5个抽象类(长虚线表示), 对集合接口的部分实现, 可扩展为自定义集合类

    AbstractCollection, AbstractList, AbstractSet, AbstractMap. AbstractSequentialList

3).实现类: 13个实现类(实线表示), 对接口的具体实现

    Vector, Stack, ArrayList, LinkedList

    HashSet, TreeSet, LinkedHashSet

    HashMap, LinkedHashMap, TreeMap, Hashtable, Properties, WeakHashMap, IdentityHashMap

4.接口详解：

1).Collection接口是一组允许重复的对象

2).Set接口继承Collection, 但不允许重复. 使用自己内部的一个排列机制

3).List接口继承Collection, 允许重复, 以元素插人的次序来放置元素.不会重新排列

4).Map接口是一组成对的键－值对象, 即所持有的是key-value(键值对). Map中不能有重复的key. 拥有自己的内部排列机制

5.关于null对象：

1).ArrayList, LinkedList, Vector允许所有对象, 包括null

2).HashSet, LinkedHashSet可以添加null, 但是TreeSet不能添加null

3).HashMap, linkedHashMap, 可以添加null.

   TreeMap不能添加键为null, 可以添加值为null的元素

   Hashtable不能添加null(无论是键还是值)

6.集合的特点对比

1.接口对比

    1).Set子接口：无序，不允许重复。检索元素效率低, 删除和插入效率高, 插入和删除不会引起元素位置改变. <对应类有HashSet, TreeSet>

    2).List子接口：有序，可以有重复元素。和数组类似, List可以动态增长, 查找元素效率高, 插入删除元素效率低, 因为会引起其他元素位置改变. <相应类有ArrayList, LinkedList, Vector>

2.实例比较

    1).HashSet: 以哈希表的形式存放元素, 插入删除速度很快. 

    2).TreeSet: 以二叉树的形式存放元素

    3).ArrayList: 动态数组

    4).LinkedList: 链表、队列、堆栈

    5).Vector是一种老的动态数组, 是线程同步的, 效率很低, 一般不赞成使用

7.Java容器的线程安全与非线程安全?

1).可以谈谈哪些是线程安全的容器, 哪些非线程安全的容器. 

    线程安全：Vector、HashTable、StringBuffer

    非线程安全：ArrayList、LinkedList、HashMap、TreeMap、StringBuilder

2).线程安全有什么好处, 有什么坏处

    线程安全即在多线程操作同一个Vector或HashTable对象时不会有任何问题. 但是线程安全必须要使用很多synchronized关键字来同步控制, 所以必然会导致性能的降低. Java后续版本出才出现了众多非线程安全的容器

3).安全与性能如何取舍. 

    如果是多个线程操作同一个对象, 那么使用线程安全的Vector; 否则, 就使用效率更高的ArrayList

4).补充说明, 非线程安全!= 不安全. 

    有人在使用过程中有一个不正确的观点: 我的程序是多线程的, 不能使用ArrayList要使用Vector, 这样才安全. 非线程安全并不是多线程环境下就不能使用. 注意我上面有说到: 多线程操作同一个对象. 注意是同一个对象. 如果是每个线程中new一个ArrayList, 而这个ArrayList只在这一个线程中使用, 那么肯定是没问题的

 

 

15.2 Collection

    Collection(单列集合): 一次添加一个元素<T>

    Collection接口是层次结构中的根接口. 构成Collection的单位, 被称之为元素. Collection接口通常不能直接使用, 但该接口提供了添加和删除元素, 管理数据的方法.

    由于List接口与Set接口都实现了Collection接口, 因此这些方法对List集合和Set集合是通用的

Collection

    |-- List：有序(存入和取出的顺序一致), 元素都有索引(角标), 元素可以重复. 

    |-- Set：元素不能重复,无序. 

【不用<>就是Object类型】

 

15.2.1 框架顶层Collection接口

(示例: basic.coll.collection.CollectionDemo)

Collection<E>的常用方法:

分类	方法	说明
添加	boolean add(E e)	添加元素
boolean addAll(Collection<?> c)	添加元素集合
boolean addAll(Collection<? extends E> c)	添加继承该类的子类元素集合
删除	boolean remove(Object o)	删除元素
boolean removeAll(Collection<?> c)	删除元素集合
void clear()	清空集合
判断	boolean contains(Object obj)	判断是否包含某个元素
boolean containsAll(Collection c)	判断是否包含某个元素集合
boolean isEmpty()	判断集合是否有元素
boolean equals(Object o)	比较hashCode是否相同
获取	int hashCode()	获取该集合对象的hashCode
int size()	获取该集合元素的大小(数量)
Iterator<E> iterator()	取出元素的方式: 迭代器
其他	boolean ratianAll(Collection<?> c)	取交集
Object[] toArray()	将集合转成Object数组
<T> T[] toArray(T[] a)	将集合转成自定义对象数组
JDK1.8	boolean removeIf(Predicate<? super E> filter)
Spliterator<E> spliterator()
Stream<E> stream()
Stream<E> parallelStream()
void forEach(Consumer<? super T> action)	遍历

说明：

    Iterator接口就是对所有的Collection容器进行元素取出的公共接口，它的对象必须依赖于具体容器, 因为每一个容器的数据结构都不同. 所以该迭代器对象是在容器中进行内部实现的. 对于使用容器者而言, 具体的实现不重要, 只要通过容器获取到该实现的迭起的对象即可, 也就是iterator方法. (迭代器模式)。

    JDK1.8 的forEach(action)方法：

       c1.forEach((str) -> {

           System.out.println(str);

       });

 

15.2.2 List接口的常用方法

(示例: basic.coll.collection.list.ListDemo)

    List接口继承了Collection接口，因此包含Collection中的所有方法，又因为List是列表类型(线性方式存储元素)，所以List接口还提供了适合于自身的常用方法(通过对象的索引来操作元素)

    要使用List集合, 通常情况下需要声明为List类型, 然后通过List接口的实现类来对集合进行实例化, List接口的实现类常用的有ArrayList和LinkedList

    特点: 有序(存入和取出的顺序一致), 元素都有索引(角标), 元素可以重复

List:(是有序的) 

    |-- ArrayList：内部是数组数据结构, 是不同步的. 替代了Vector. 查询的速度快.

    |-- LinkedList：内部是链表数据结构, 是不同步的. 增删元素的速度很快. 

    |-- Vector：内部是数组数据结构, 是同步的. 增删, 查询都很慢

List的常用方法:

分类	方法	说明
添加	boolean add(E e)	添加对象
void add(int index, E element)	在索引位置插入元素(索引从0开始)
boolean addAll(Collection<?> c)	添加元素集合
boolean addAll(Collection<? extends E> c)	添加继承该类的子类元素集合
boolean addAll(int index, Collection<? extends E> c)	在指定索引位置插入Collection子类元素集合(索引从0开始)
修改	E set(int index, E element)	指定元素替换列表中指定索引位置的元素, 返回被替换的元素
删除	E remove(int index)	移除指定索引位置的元素, 返回被移除的元素
boolean remove(Object o)	删除元素
boolean removeAll(Collection<?> c)	删除元素集合
void clear()	清空集合
判断	boolean contains(Object obj)	判断是否包含某个元素
boolean containsAll(Collection c)	判断是否包含某个集合
boolean isEmpty()	判断集合是否有元素
boolean equals(Object o)	比较hashCode是否相同
获取	E get(int index)	用于获取指定索引位置的元素
int indexOf(Object o)	该方法返回列表中对象最后一次出现的索引位置, 如果集合中不包含该元素, 则返回-1
int lastIndexOf(Object o)	该方法返回列表中对象最后一次出现的索引位置, 如果集合中不包含该元素, 则返回-1
ListIterator<E> listIterator()	用来获取一个包含所有对象的ListIterator列表迭代器
ListIterator<E> listIterator(int index)
List<E> subList(int fromIndex, int toIndex)	获取从索引fromIndex到toIndex之间的元素对象
int hashCode()	获取该集合对象的hashCode
int size()	获取该集合元素的大小(数量)
Iterator<E> iterator()	取出元素的方式: 迭代器
其他	boolean ratianAll(Collection<?> c)	取交集
Object[] toArray()	将集合转成Object数组
<T> T[] toArray(T[] a)	将集合转成自定义对象数组
JDK1.8	void replaceAll(UnaryOperator<E> operator)
void sort(Comparator<? super E> c)
boolean removeIf(Predicate<? super E> filter)
Spliterator<E> spliterator()
Stream<E> stream()
Stream<E> parallelStream()
void forEach(Consumer<? super T> action)	遍历

 

15.2.2.1 ArrayList类

(示例: basic.coll.collection.list.ListIteratorDemo)

    该类实现了可变的数组, 允许所有元素, 包括null.

    底层实现:数组实现, Object[]保存数据

    优点:可以根据索引位置对集合进行快速的随机访问

    缺点:向指定的索引位置插入对象或删除对象的速度较慢

    语法: ArrayList<Object> list = new ArrayList<Object>();

方法(只列出基于List扩展的): 

分类	方法	说明
构造	ArrayList()	初始一个初始容量为10的空列表
ArrayList(int initialCapacity)	构造一个包含指定collection的元素的列表, 这些元素是按照该collection的迭代器返回它们的顺序排列的
ArrayList(Collection<? extends E> c)	构造一个具有指定初始容量的空列表
数量	void trimToSize()	将此 ArrayList 实例的容量调整为列表的当前大小
void ensureCapacity(int minCapacity)	如有必要，增加此 ArrayList 实例的容量，以确保它至少能够容纳最小容量参数所指定的元素数
复制	Object clone()	返回此 ArrayList 实例的浅表副本(浅克隆)

 

15.2.2.2 LinkedList类

(示例: basic.coll.collection.list.LinkedListDemo)

    该类采用链表结构保存对象, 允许所有元素, 包括null

    底层实现:Node<E> first, last(存储当前的数值, 添加时加入到last.next), 用链表实现

    优点:便于向集合中插入和删除对象, 经常需要向集合中插入, 删除对象时, 使用LinkedList类实现的List集合的效率较好

    缺点:对于随机访问集合中的对象, 效率较慢

    语法:List<String> list = new LinkedList<String>();

    场景:可以拿来实现堆栈和队列

方法(只列出基于List扩展的): 

分类	方法	说明
构造	LinkedList()	构造一个空列表
LinkedList(Collection<? extends E> c)	构造一个包含指定collection中的元素的列表, 这些元素按其collection的迭代器返回的顺序排列
添加	void addFirst(E e)	将指定元素插入此列表的开头
void addLast(E e)	将指定元素添加到此列表的结尾
boolean offer(E e)	将指定元素添加到此列表的末尾(最后一个元素)
boolean offerFirst(E e)	在此列表的开头插入指定的元素
boolean offerLast(E e)	在此列表末尾插入指定的元素
void push(E e)	将元素推入此列表所表示的堆栈
获取	E element()	获取但不移除此列表的头(第一个元素)
E getFirst()	返回此列表的第一个元素
E getLast()	返回此列表的最后一个元素
E peek()	获取但不移除此列表的头(第一个元素)
E peekFirst()	获取但不移除此列表的第一个元素; 如果此列表为空, 则返回 null
E peekLast()	获取但不移除此列表的最后一个元素; 如果此列表为空, 则返回 null
E poll()	获取并移除此列表的头(第一个元素)
E pollFirst()	获取并移除此列表的第一个元素; 如果此列表为空, 则返回 null
E pollLast()	获取并移除此列表的最后一个元素; 如果此列表为空, 则返回 null
E pop()	从此列表所表示的堆栈处弹出一个元素
删除	E remove()	获取并移除此列表的头(第一个元素)
E removeFirst()	移除并返回此列表的第一个元素
boolean removeFirstOccurrence(Object o)	从此列表中移除第一次出现的指定元素(从头部到尾部遍历列表时)
E removeLast()	移除并返回此列表的最后一个元素
boolean removeLastOccurrence(Object o)	从此列表中移除最后一次出现的指定元素(从头部到尾部遍历列表时)
遍历	Iterator<E> descendingIterator()	返回以逆向顺序在此双端队列的元素上进行迭代的迭代器
克隆	Object clone()	返回此 LinkedList 实例的浅表副本(浅克隆)

 

15.2.2.3 Vector类

(示例: basic.coll.collection.list.VectorDemo)

    该类实现了可变的数组, 允许所有元素, 包括null.

    底层实现:数组实现, Object[]保存数据, 所有方法均加了synchronized(即同步)

    优点:保证数据的同步性, 在访问的性能上比ArrayList差

    缺点:在向指定的索引位置插入对象或删除对象的性能上比ArrayList差

    语法: Vector<Object> list = new Vector<Object>();

方法(所有方法均加了synchronized关键字, 只列出基于List扩展的): 

分类	方法	说明
构造	Vector()	构造一个空向量, 使其内部数据数组的大小为10, 其标准容量增量为零
Vector(int initialCapacity)	使用指定的初始容量和等于零的容量增量构造一个空向量
Vector(int initialCapacity, int capacityIncrement)	使用指定的初始容量和容量增量构造一个空的向量
Vector(Collection<? extends E> c)	构造一个包含指定collection中的元素的向量, 这些元素按其collection的迭代器返回元素的顺序排列
添加	synchronized void addElement(E obj)	将指定的组件添加到此向量的末尾, 将其大小增加 1
synchronized void insertElementAt(E obj, int index)	将指定对象作为此向量中的组件插入到指定的 index 处
获取	synchronized int capacity()	返回此向量的当前容量
synchronized E elementAt(int index)	返回指定索引处的组件
Enumeration<E> elements()	返回此向量的组件的枚举
synchronized E firstElement()	返回此向量的第一个组件(位于索引0)处的项
synchronized E lastElement()	返回此向量的最后一个组件
synchronized int lastIndexOf(Object o, int index)	返回此向量中最后一次出现的指定元素的索引, 从 index 处逆向搜索, 如果未找到该元素, 则返回 -1
删除	synchronized void removeElementAt(int index)	删除指定索引处的组件
synchronized boolean removeElement(Object obj)	从此向量中移除变量的第一个(索引最小的)配项
synchronized void removeAllElements()	从此向量中移除全部组件, 并将其大小设置为零
设置	synchronized void setSize(int newSize)	设置此向量的大小
synchronized void setElementAt(E obj, int index)	将此向量指定 index 处的组件设置为指定的对象
synchronized void trimToSize()	对此向量的容量进行微调, 使其等于向量的当前大小
synchronized void ensureCapacity(int minCapacity)	增加此向量的容量(如有必要), 以确保其至少能够保存最小容量参数指定的组件数
复制	synchronized void copyInto(Object[] anArray)	将此向量的组件复制到指定的数组中
synchronized Object clone()	返回向量的一个副本, 浅克隆

 

15.2.3 Set接口的常用方法

(示例: basic.coll.collection.set.SetDemo)

    Set集合由Set接口和Set接口的实现类组成, 也包含Collection接口的所有方法

Set:元素不可以重复, 是无序. (根据算法排序,所以无序)

    Set接口中的方法和Collection一致. 

    |-- HashSet：内部数据结构是哈希表, 是不同步的. 

       |-- LinkedHashSet：

    |-- TreeSet：可以对Set集合中的元素进行排序. 是不同步的.  

    要使用Set集合, 需要声明为Set类型, 实现类常用的有HashSet和TreeSet 

    由于Set集合中不允许存在重复值, 因此可以使用Set集合中的addAll()方法, 将Collection集合添加到Set集合中并除掉重复值

    由于Set集合中的对象时无序的, 遍历Set结合的结果与插入Set集合的顺序并不相同

Set接口中的常用方法

分类	方法	说明
添加	boolean add(E e)	如果此Set集合尚未保存在指定的集合, 则添加此元素
boolean addAll(Collection<?> c)	将参数集合中所有元素添加到此Set集合的尾部
boolean addAll(Collection<? extends E> c)	添加继承该类的子类元素集合
删除	boolean remove(Object o)	删除元素
boolean removeAll(Collection<?> c)	删除元素集合
void clear()	清空集合
判断	boolean contains(Object obj)	判断是否包含某个元素
boolean containsAll(Collection c)	判断是否包含某个元素集合
boolean isEmpty()	判断集合是否有元素
boolean equals(Object o)	比较hashCode是否相同
获取	int hashCode()	获取该集合对象的hashCode
int size()	获取该集合元素的大小(数量)
Iterator<E> iterator()	取出元素的方式: 迭代器
其他	boolean ratianAll(Collection<?> c)	取交集
Object[] toArray()	将集合转成Object数组
<T> T[] toArray(T[] a)	将集合转成自定义对象数组
JDK1.8	boolean removeIf(Predicate<? super E> filter)
Spliterator<E> spliterator()
Stream<E> stream()
Stream<E> parallelStream()
void forEach(Consumer<? super T> action)	遍历

1.如何保证该集合的元素唯一性呢？

    是通过对象的hashCode和equals方法来完成对象唯一性的. 

        1).如果对象的hashCode值不同, 那么不用判断equals方法, 就直接存储到哈希表中.  

        2).如果对象的hashCode值相同, 那么要再次判断对象的equals方法是否为true. 

    如果为true, 视为相同元素, 不存. 如果为false, 那么视为不同元素, 就进行存储. 

【记住: 如果元素要存储到HashSet集合中, 必须覆盖hashCode方法和equals方法. 】

    一般情况下, 如果定义的类会产生很多对象, 比如人, 学生, 书, 通常都需要覆盖equals, hashCode方法. 

2.建立对象判断是否相同的依据. 

    if (this.hashCode() == obj.hashCode() && this.equals(obj))

3.哈希表确定元素是否相同

1).判断的是两个元素的哈希值是否相同. 

    如果相同, 在判断两个对象的内容是否相同. 

2).判断哈希值相同, 其实判断的是对象的hashCode的方法. 判断内容相同, 用的是equals方法. 

[注意:如果哈希值不同, 是不需要判断equals]

4.判断元素唯一性的方式:

    就是根据比较方法的返回结果是否是0, 是0, 就是相同元素, 不存.  

TreeSet对元素进行排序的两种

1).方式一：让元素自身具备比较功能, 元就需要实现Comparable接口. 覆盖compareTo方法. 如果不要按照对象中具备的自然顺序进行排序. 如果对象中不具备自然顺序. 怎么办？

2).方式二：让集合自身具备比较功能, 定义一个类实现Comparator接口, 覆盖compare方法. 将该类对象作为参数传递给TreeSet集合的构造函数. 

 

15.2.3.1 HashSet类

(示例: basic.coll.collection.set.HashSetDemo)

    该类实现了HashMap, 允许所有元素, 包括null. 但是不允许重复的键

    底层实现:底层使用HashMap保存数据, 其中对象作为map的key, 所以不允许存在重复的键, 所以Set不可重复. HashSet集合数据结构是哈希表, 所以存储元素的时候, 使用的元素的hashCode方法来确定位置, 如果位置相同, 在通过元素的equals来确定是否相同

    语法: HashSet<Object> list = new HashSet<Object>();

方法(所有方法均加了synchronized关键字, 只列出基于Set扩展的): 

分类	方法	说明
构造	HashSet()	造一个新的空set, 其底层HashMap实例的默认初始容量是 16, 加载因子是0.75
HashSet(Collection<? extends E> c)	构造一个包含指定collection中的元素的新 set
HashSet(int initialCapacity, float loadFactor)	构造一个新的空set, 其底层HashMap实例具有指定的初始容量和指定的加载因子
HashSet(int initialCapacity)	构造一个新的空set, 其底层HashMap实例具有指定的初始容量和默认的加载因子(0.75)
克隆	Object clone()	返回此HashSet实例的浅表副本: 并没有复制这些元素本身, 浅克隆

 

15.2.3.2 LinkedHashSet类(HashSet的子类)

(示例: basic.coll.collection.set.LinkedHashSetDemo)

    该类实现了HashMap, 允许所有元素, 包括null. 但是不允许重复的键(有序)

    底层实现:底层使用HashMap保存数据, 其中对象作为map的key, 所以不允许存在重复的键, 所以Set不可重复. HashSet集合数据结构是哈希表, 所以存储元素的时候, 使用的元素的hashCode方法来确定位置, 如果位置相同, 在通过元素的equals来确定是否相同

    具有可预知迭代顺序的 Set 接口的哈希表和链接列表实现. 此实现与HashSet的不同之外在于, 后者维护着一个运行于所有条目的双重链接列表. 此链接列表定义了迭代顺序, 即按照将元素插入到set中的顺序(插入顺序)进行迭代

    优点:删除和插入效率高

    缺点:检索元素效率低

    语法: LinkedHashSet<Object> list = new LinkedHashSet<Object>();

方法(只列出基于Set扩展的): 

分类	方法	说明
构造	LinkedHashSet()	构造一个带默认初始容量(16)和加载因子(0.75)的新空链接哈希set
LinkedHashSet(int initialCapacity)	构造一个带指定初始容量和默认加载因子(0.75)的新空链接哈希set
LinkedHashSet(int initialCapacity, float loadFactor)	构造一个带有指定初始容量和加载因子的新空链接哈希set
LinkedHashSet(Collection<? extends E> c)	构造一个与指定collection中的元素相同的新链接哈希set

 

15.2.3.3 TreeSet类

(示例: basic.coll.collection.set.TreeSetDemo)

    该类基于TreeMap的NavigableSet实现, 允许所有元素, 不允许包括null. 但是不允许重复的键

    底层实现:底层基于TreeMap的NavigableSet保存数据, 其中对象作为map的key, 所以不允许存在重复的键, 所以Set不可重复. HashSet集合数据结构是哈希表, 所以存储元素的时候, 使用的元素的hashCode方法来确定位置, 如果位置相同, 在通过元素的equals来确定是否相同

    优点:删除和插入效率高

    缺点:检索元素效率低

    语法: TreeSet<Object> list = new TreeSet<Object>();

方法(只列出基于Set扩展的): 

分类	方法	说明
构造	TreeSet()	构造一个新的空set, 该set根据其元素的自然顺序进行排序
TreeSet(NavigableMap<E,Object> m)
TreeSet(Comparator<? super E> comparator)	构造一个新的空TreeSet, 它根据指定比较器进行排序
TreeSet(Collection<? extends E> c)	构造一个包含指定collection元素的新 TreeSet, 它按照其元素的自然顺序进行排序
TreeSet(SortedSet<E> s)	构造一个与指定有序set具有相同映射关系和相同排序的新TreeSet
获取	Iterator<E> descendingIterator()	返回在此set元素上按降序进行迭代的迭代器
NavigableSet<E> descendingSet()	返回此set中所包含元素的逆序视图
NavigableSet<E> subSet(E fromElement, boolean fromInclusive, E toElement, boolean toInclusive)	返回此set的部分视图, 其元素范围从fromElement到toElement
NavigableSet<E> headSet(E toElement, boolean inclusive)	返回此set的部分视图, 其元素小于(或等于, 如果inclusive为true)toElement
NavigableSet<E> tailSet(E fromElement, boolean inclusive)	返回此set的部分视图, 其元素大于(或等于, 如果inclusive为true)fromElement
SortedSet<E> subSet(E fromElement, E toElement)	返回此set的部分视图, 其元素从fromElement(包括)到toElement(不包括)
SortedSet<E> headSet(E toElement)	返回此set的部分视图, 其元素严格小于toElement
SortedSet<E> tailSet(E fromElement)	返回此set的部分视图, 其元素大于等于fromElement
Comparator<? super E> comparator()	返回对此set中的元素进行排序的比较器; 如果此set使用其元素的自然顺序, 则返回null
E first()	返回此set中当前第一个(最低)元素
E last()	返回此set中当前最后一个(最高)元素
E lower(E e)	返回此set中严格小于给定元素的最大元素; 如果不存在这样的元素, 则返回 null
E floor(E e)	返回此 set 中小于等于给定元素的最大元素; 如果不存在这样的元素, 则返回 null
E ceiling(E e)	返回此 set 中大于等于给定元素的最小元素; 如果不存在这样的元素, 则返回 null
E higher(E e)	返回此 set 中严格大于给定元素的最小元素; 如果不存在这样的元素, 则返回 null
E pollFirst()	获取并移除第一个(最低)元素; 如果此set为空, 则返回null
E pollLast()	获取并移除最后一个(最高)元素; 如果此set为空, 则返回 null
Object clone()	返回TreeSet实例的浅表副本, 浅克隆

 

15.2.4 Collection泛型

jdk1.5出现的安全机制, 不用<>就是Object类型

好处:1).将运行时期的问题ClassCastException转到了编译时期(编写代码时期)

      2).避免了强制转换的麻烦

泛型<>什么时候用?(泛型类同理) 

    当操作的引用数据类型不确定的时候. 就使用<>. 将要操作的引用数据类型传入即可, 其实<>就是一个用于接收具体引用数据类型的参数范围

【注: 在程序中,只要用到了带有<>的类或者接口, 就要明确传入的具体引用数据类型】

    泛型技术是给编译器使用的技术, 用于编译时期. 确保了类型的安全. 运行时. 会将泛型去掉, 生成的class文件中是不带泛型的, 这个称为泛型的擦除, 为了兼容运行的类加载器, 所以擦除

    泛型的补偿: 在运行时, 通过获取元素的类型进行转换动作, 不用使用者再强制转换了

泛型的通配符: ？未知类型(定义泛型函数时候)

    ? extends E：接收E类型或者E的子类型对象(上限). 一般存储对象的时候用. 比如添加元素addAll

    ? super E：接收E类型或者E的父类型对象(下限). 一般取出对象的时候用. 比如比较器

 

15.2.7 使用集合的技巧

需要唯一吗?

    |-- 需要: set

        |--需要制定顺序吗?

           |-- 需要: TreeSet

           |--不需要: HashSet, 但是想要一个和存储一致的顺序(有序) : LinkedHashSet

    |-- 不需要: List

        |--需要频繁增删吗？

           |--需要: LinkedList

           |-- 不需要: ArrayList

前缀名: 集合的数据结构: array, linked, hash, tree

后缀名: 集合所属的体系: List, Set

记忆方法: 

    array: 数组, 查询快, 有角标

    linked: 链表, 增删快, add get remove + first last方法

    hash: 哈希表, 唯一性, 元素需要覆盖hashcode方法和equals方法

    tree: 二叉树, 排序, 两个接口: Comparable, Comparator

而且通常这些常用的集合容器都是不同步的

显示的2种方式

1).迭代器: Iterator(3个方法) [Collection子类用的]

    1).hasNext()  是否还有下一个元素.
    2).next()  返回下一个元素.
    3).remove()  删除当前元素.

       Iterator<String>lts= s.iterator();

       while(lts.hasNext()) {

           System.out.println(lts.next());

       }

2).枚举: Enumeration(2个方法) [Vector使用的]

    1).boolean hasMoreElements()        

    2).Object nextElement()

       Enumeration<String>en= v.elements();

       while(en.hasMoreElements()){

           System.out.println("en.nextElement(): "+ en.nextElement());

       }

3).Iterator和Enumeration的区别

    Iterator是用来替代Enumeration的, Enumeration中只定义了两个方法, 不具备删除功能.

4).调用next()方法后才可以调用remove()方法

    而且每次调用next()后最多只能调用一次remove()方法, 否则抛出IllegalStateException异常.

 

 

15.3 Map

    Map(双列集合): 一次添加一对元素<K,V>, 存储的是键值对, 保证键的唯一性

    Map接口提供了将键映射到值得对象, 一个映射不能包含重复的键, 每个键最多只能映射到一个值. 

    由于Map集合中的元素是通过key, value进行存储的, 要获取集合中指定的key值或value值, 需要先通过相应的方法获取key集合或value集合, 再遍历key集合或value集合获取指定值

 

15.3.1 框架的顶层Map接口

(示例: basic.coll.map.MapDemo)

Map常用的子类

    |-- Hashtable：内部结构是哈希表, 是同步的. 不允许null作为键, null作为值. 

       |-- Properties：用来存储键值对型的配置文件的信息, 可以和IO技术相结合.  

    |-- HashMap：内部结构是哈希表, 不是同步的. 允许null作为键, null作为值. 无序

       |-- LinkedHashMap：有序哈希Map

    |-- TreeMap：内部结构是二叉树, 不是同步的. 可以对Map集合中的键进行排序. 

Map接口中的常用方法

分类	方法	说明
添加	V put(K key, V value)	向集合中添加指定的key与value的映射关系
void putAll(Map<? extends K, ? extends V> m)	添加一个map集合进去
删除	V remove(Object key)	根据指定的key删除这个键值对
boolean remove(Object key, Object value)	JDK1.8, 子类实现
void clear()	清空map集合
判断	boolean containsKey(Object key)	如果此映射包含指定键的映射关系, 则返回true
boolean containsValue(Object value)	如果此映射将一个或多个键映射到指定值, 则返回true
boolean equals(Object o)	比较的是元素是否相同
boolean isEmpty()	判断集合是否有元素
获取	int size()	获取键值对的个数
V get(Object key)	如果存在指定的键对象, 则返回该对象对应的值, 否则返回null
V getOrDefault(Object key, V defaultValue)	JDK1.8, 子类实现
Set<K> keySet()	返回该集合中的所有键对象组成的Set集合
Collection<V> values()	返回该集合中所有值对象形成的Collection集合
Set<Map.Entry<K, V>> entrySet()
void forEach(BiConsumer<? super K, ? super V> action)	JDK1.8, 子类实现
JDK1.8 子类实现	V replace(K key, V value)
boolean replace(K key, V oldValue, V newValue)
void replaceAll(BiFunction<? super K, ? super V, ? extends V> function)
V putIfAbsent(K key, V value)
V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction)
V computeIfPresent(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction)
V compute(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction)
V merge(K key, V value, BiFunction<? super V, ? super V, ? extends V> remappingFunction)

遍历Map数据总结：

    1).Collection方法, 只遍历value

    Collection<String>values= m1.values();

    Iterator<String>it1= values.iterator();

    while(it1.hasNext()) {

       System.out.println(it1.next());

    }

    2).keySet方法(取出map中的所有元素)

    原理：通过keySet方法获取map中所有的键所在的Set集合, 在通过Set的迭代器获取到每一个键, 再对每一个键通过map集合的get方法获取其对应的值即可. 

    Set<Integer>keySet= m1.keySet();

    Iterator<Integer>its= keySet.iterator();

    while(its.hasNext()) {

       Integer key= its.next();

       String value= m1.get(key);

       System.out.print("{key="+ key+ ", value="+ value+ "},");

    }

    3).entrySet方法，效率最高

    通过Map转成set就可以迭代. 找到了另一个方法. entrySet。该方法将键和值的映射关系作为对象存储到了Set集合中, 而这个映射关系的类型就是Map.Entry类型

    Set<Map.Entry<Integer, String>> entrySet= m1.entrySet();

    Iterator<Map.Entry<Integer, String>> it= entrySet.iterator();

    while(it.hasNext()) {

       Map.Entry<Integer, String> me= it.next();

       Integer key= me.getKey();

       String value= me.getValue();

       System.out.print("{key="+ key+ ", value="+ value+ "},");

    }

    4).JDK1.8新特性, forEach方法

    m1.forEach((key, value) -> {

       System.out.print("{key="+ key+ ", value="+ value+ "},");

    });

 

15.3.2 Map接口的实现类

    Map接口常用的实现类有HashMap和TreeMap, 通常建议使用HashMap实现类实现Map集合, 因为由HashMap类实现的Map集合对于添加和删除映射关系效率更高.

    HashMap是基于哈希表的Map接口的实现, HashMap通过哈希吗对其内部的映射关系进行快速查找. 由HashMap类实现的Map集合对于添加或删除映射关系效率较高. 而TreeMap中的映射关系存在一定的顺序, 如果希望Map集合中的对象存在一定的顺序, 应该使用TreeMap类实现Map集合.

 

15.3.2.1 HashMap类

(示例: basic.coll.map.HashMapDemo)

    该类基于哈希表的Map接口的实现, 此实现提供所有可选的映射操作, 并允许使用null值和null键, 但必须保证键的唯一性. HashMap通过哈希对其内部的映射关系进行快速查找, 此类不保证映射的顺序, 特别是不保证该顺序恒久不变(无序).

    底层实现:Node<K, V> implements Map.Entry<K,V>, 内置对象实现(链表) + 数组的方式

    语法: HashMap<K, V> list = new HashMap<K, V>();

方法(只列出基于Map扩展的, JDK1.8方法均由该类实现): 

分类	方法	说明
构造	HashMap()	构造一个具有默认初始容量(16)和默认加载因子(0.75)的空HashMap
HashMap(int initialCapacity)	构造一个带指定初始容量和默认加载因子(0.75)的空HashMap
HashMap(int initialCapacity, float loadFactor)	构造一个带指定初始容量和加载因子的空HashMap
HashMap(Map<? extends K, ? extends V> m)	构造一个映射关系与指定Map相同的新HashMap
获取	V getOrDefault(Object key, V defaultValue)	JDK1.8
void forEach(BiConsumer<? super K, ? super V> action)	JDK1.8
删除	boolean remove(Object key, Object value)	JDK1.8
JDK1.8	V replace(K key, V value)
boolean replace(K key, V oldValue, V newValue)
void replaceAll(BiFunction<? super K, ? super V, ? extends V> function)
V putIfAbsent(K key, V value)
V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction)
V computeIfPresent(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction)
V compute(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction)
V merge(K key, V value, BiFunction<? super V, ? super V, ? extends V> remappingFunction)
克隆	Object clone()	浅克隆

 

15.3.2.2 TreeMap类

(示例: basic.coll.map.TreeMapDemo)

    该类不仅实现了Map接口, 还实现了java.util.SortedMap接口. 因此集合中的映射关系具有一定的顺序. 但在添加、删除和定位映射关系上, TreeMap类比HashMap性能差一点. 

    由于TreeMap类实现的Map集合中的映射关系是根据键对象按照一定的顺序排列的, 因此不允许键对象是null

    可以通过HashMap类创建Map集合, 当需要顺序输出时, 再创建一个完成相同映射关系的TreeMap类实例

方法(只列出基于Map扩展的, JDK1.8方法均由该类实现): 

分类	方法	说明
构造	TreeMap ()	使用键的自然顺序构造一个新的、空的树映射
TreeMap(Comparator<? super K> comparator)	构造一个新的、空的树映射, 该映射根据给定比较器进行排序
TreeMap(Map<? extends K, ? extends V> m)	构造一个与给定映射具有相同映射关系的新的树映射, 该映射根据其键的自然顺序进行排序
TreeMap(SortedMap<K, ? extends V> m)	构造一个与指定有序映射具有相同映射关系和相同排序顺序的新的树映射
获取	Map.Entry<K,V> firstEntry()	返回一个与此映射中的最小键关联的键-值映射关系; 如果映射为空, 则返回null
K firstKey()	返回此映射中当前第一个(最低)键
Map.Entry<K,V> lastEntry()	返回与此映射中的最大键关联的键-值映射关系; 如果映射为空, 则返回null
K lastKey()	返回映射中当前最后一个(最高)键
Map.Entry<K,V> pollFirstEntry()	移除并返回与此映射中的最小键关联的键-值映射关系; 如果映射为空, 则返回null
Map.Entry<K,V> pollLastEntry()	移除并返回与此映射中的最大键关联的键-值映射关系; 如果映射为空, 则返回null
Map.Entry<K,V> floorEntry(K key)	返回一个键-值映射关系, 它与小于等于给定键的最大键关联; 如果不存在这样的键, 则返回 null
K floorKey(K key)	返回小于等于给定键的最大键; 如果不存在这样的键, 则返回null
Map.Entry<K,V> ceilingEntry(K key)	返回一个键-值映射关系, 它与大于等于给定键的最小键关联; 如果不存在这样的键, 则返回 null
K ceilingKey(K key)	返回大于等于给定键的最小键; 如果不存在这样的键, 则返回null
Map.Entry<K,V> higherEntry(K key)	返回一个键-值映射关系, 它与严格大于给定键的最小键关联; 如果不存在这样的键, 则返回null
K higherKey(K key)	返回严格大于给定键的最小键; 如果不存在这样的键, 则返回null
Map.Entry<K,V> lowerEntry(K key)	返回一个键-值映射关系, 它与严格小于给定键的最大键关联; 如果不存在这样的键, 则返回null
K lowerKey(K key)	返回严格小于给定键的最大键; 如果不存在这样的键, 则返回nul
Comparator<? super K> comparator()	返回对此映射中的键进行排序的比较器; 如果此映射使用键的自然顺序, 则返回null
NavigableSet<K> navigableKeySet()	返回此映射中所包含键的NavigableSet视图
NavigableSet<K> descendingKeySet()	返回此映射中所包含键的逆序NavigableSet视图
NavigableMap<K, V> descendingMap()	返回此映射中所包含映射关系的逆序视图
SortedMap<K,V> headMap(K toKey)	返回此映射的部分视图, 其键值严格小于toKey
NavigableMap<K,V> headMap(K toKey, boolean inclusive)	返回此映射的部分视图, 其键小于(或等于, 如果inclusive为true)toKey
SortedMap<K,V> tailMap(K fromKey)	返回此映射的部分视图, 其键大于等于fromKey
NavigableMap<K,V> tailMap(K fromKey, boolean inclusive)	返回此映射的部分视图, 其键大于(或等于, 如果inclusive为true)fromKey
SortedMap<K,V> subMap(K fromKey, K toKey)	返回此映射的部分视图, 其键值的范围从fromKey(包括)到toKey(不包括)
NavigableMap<K,V> subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive)	返回此映射的部分视图, 其键的范围从fromKey到toKey
void forEach(BiConsumer<? super K, ? super V> action)	JDK1.8
JDK1.8	V replace(K key, V value)
boolean replace(K key, V oldValue, V newValue)
void replaceAll(BiFunction<? super K, ? super V, ? extends V> function)
克隆	Object clone()	返回此TreeMap实例的浅表副本,  浅克隆

 

15.3.2.3 Hashtable类

(示例: basic.coll.map.HashtableDemo)

    此类实现一个哈希表, 该哈希表将键映射到相应的值. 任何非null对象都可以用作键或值. 为了成功地在哈希表中存储和获取对象, 用作键的对象必须实现hashCode方法和equals方法. 所有方法均加了synchronized(即同步) 

    底层实现:Node<K, V> implements Map.Entry<K,V>, 内置对象实现(链表) + 数组的方式

方法(只列出基于Map扩展的, JDK1.8方法均由该类实现): 

分类	方法	说明
构造	Hashtable()	用默认的初始容量(11)和加载因子(0.75)构造一个新的空哈希表
Hashtable(int initialCapacity)	用指定初始容量和默认的加载因子(0.75)构造一个新的空哈希表
Hashtable(int initialCapacity, float loadFactor)	用指定初始容量和指定加载因子构造一个新的空哈希表
Hashtable(Map<? extends K, ? extends V> t)	构造一个与给定的Map具有相同映射关系的新哈希表
获取	synchronized Enumeration<K> keys()	返回此哈希表中的键的枚举
synchronized Enumeration<V> elements()	返回此哈希表中的值的枚举
synchronized Object clone()	创建此哈希表的浅表副本, 浅克隆
synchronized String toString()	返回此Hashtable对象的字符串表示形式, 其形式为ASCII字符","(逗号加空格)分隔开的、括在括号中的一组条目
synchronized boolean equals(Object o)	按照Map接口的定义, 比较指定Object与此Map是否相等
synchronized int hashCode()	按照Map接口的定义, 返回此Map的哈希码值
JDK1.8	synchronized V getOrDefault(Object key, V defaultValue)
synchronized void forEach(BiConsumer<? super K, ? super V> action)
synchronized void replaceAll(BiFunction<? super K, ? super V, ? extends V> function)
synchronized V putIfAbsent(K key, V value)
synchronized boolean remove(Object key, Object value)
synchronized boolean replace(K key, V oldValue, V newValue)
synchronized V replace(K key, V value)
synchronized V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction)
synchronized V computeIfPresent(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction)
synchronized V compute(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction)
synchronized V merge(K key, V value, BiFunction<? super V, ? super V, ? extends V> remappingFunction)

 

15.3.2.4 Properties(Hashtable子类)

(示例: basic.coll.map.PropertiesDemo)

Map常用的子类

    |--Hashtable :内部结构是哈希表, 是同步的. 不允许null作为键, null作为值. 

       |--Properties:用来存储键值对型的配置文件的信息, 可以和IO技术相结合. 

    Properties类表示了一个持久的属性集. Properties可保存在流中或从流中加载

特点: 1.该集合中的键和值都是字符串类型

     2.集合中的数据可以保存到流中, 或从流中获取

通过该集合用于操作以键值对形式存在配置文件

分类	方法	说明
构造	Properties()	创建一个无默认值的空属性列表
Properties(Properties defaults)	创建一个带有指定默认值的空属性列表
操作	String getProperty(String key)	用指定的键在此属性列表中搜索属性
String getProperty(String key, String defaultValue)	用指定的键在属性列表中搜索属性
synchronized Object setProperty(String key, String value)	调用 Hashtable 的方法 put
获取	Enumeration<?> propertyNames()	返回属性列表中所有键的枚举, 如果在主属性列表中未找到同名的键, 则包括默认属性列表中不同的键
Set<String> stringPropertyNames()	返回此属性列表中的键集, 其中该键及其对应值是字符串, 如果在主属性列表中未找到同名的键, 则还包括默认属性列表中不同的键
其他	synchronized void load(Reader reader)	按简单的面向行的格式从输入字符流中读取属性列表(键和元素对)
synchronized void load(InputStream inStream)	从输入流中读取属性列表(键和元素对)
void save(OutputStream out, String comments)	已过时, 如果在保存属性列表时发生I/O错误, 则此方法不抛出IOException. 保存属性列表的首选方法是通过store(OutputStream out, String comments)方法或storeToXML(OutputStream os, String comment)方法来进行
void store(Writer writer, String comments)	以适合使用load(Reader)方法的格式, 将此Properties表中的属性列表(键和元素对)写入输出字符
void store(OutputStream out, String comments)	以适合使用load(InputStream)方法加载到Properties表中的格式, 将此Properties表中的属性列表(键和元素对)写入输出流
synchronized void loadFromXML(InputStream in)	将指定输入流中由XML文档所表示的所有属性加载到此属性表中
void storeToXML(OutputStream os, String comment)	发出一个表示此表中包含的所有属性的XML文档
void storeToXML(OutputStream os, String comment, String encoding)	使用指定的编码发出一个表示此表中包含的所有属性的XML文档
void list(PrintStream out)	将属性列表输出到指定的输出流
void list(PrintWriter out)	将属性列表输出到指定的输出流

    因为Properties继承于Hashtable, 所以可对Properties对象应用put和putAll方法. 不建议使用这两个方法, 因为它们允许调用者插入其键或值不是String的项, 相反, 应该使用setProperty方法. 如果在"不安全"的Properties对象(即包含非String的键或值)上调用store或save方法, 则该调用将失败

    类似地, 如果在"不安全"的Properties对象(即包含非String的键)上调用propertyNames或list方法, 则该调用将失败

    load(Reader)/store(Writer, String)方法按下面所指定的、简单的面向行的格式在基于字符的流中加载和存储属性. 除了输入/输出流使用ISO 8859-1字符编码外, load(InputStream)/store(OutputStream, String)方法与load(Reader)/store(Writer, String)对的工作方式完全相同. 可以使用Unicode转义来编写此编码中无法直接表示的字符; 转义序列中只允许单个'u'字符. 可使用native2ascii工具对属性文件和其他字符编码进行相互转换

    loadFromXML(InputStream)和storeToXML(OutputStream, String, String)方法按简单的XML 格式加载和存储属性. 默认使用UTF-8字符编码, 但如果需要, 可以指定某种特定的编码. XML属性文档具有以下DOCTYPE声明: <!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">

 

15.3.2.5 LinkedHashMap(HashMap子类)

(示例: basic.coll.map.LinkedHashMapDemo)

    Map 接口的哈希表和链接列表实现, 具有可预知的迭代顺序. 此实现与HashMap的不同之处在于: 该类维护着一个运行于所有条目的双重链接列表, 是有序的HashMap

方法(只列出基于Map扩展的, JDK1.8方法均由该类实现): 

分类	方法	说明
构造	LinkedHashMap()	构造一个带默认初始容量(16)和加载因子(0.75)的空插入顺序LinkedHashMap实例
LinkedHashMap(int initialCapacity)	构造一个带指定初始容量和默认加载因子(0.75)的空插入顺序LinkedHashMap实例
LinkedHashMap(int initialCapacity, float loadFactor)	构造一个带指定初始容量和加载因子的空插入顺序LinkedHashMap实例
LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder)	构造一个映射关系与指定映射相同的插入顺序LinkedHashMap实例
LinkedHashMap(Map<? extends K, ? extends V> m)	构造一个带指定初始容量、加载因子和排序模式的空LinkedHashMap实例

 

15.4 迭代器

    利用Iterator接口创建迭代器, Iterator接口位于java.util包下. Iterator接口有3个方法:

        1).hasNext(): 如果仍有元素可以迭代, 则返回true

        2).next(): 返回迭代的下一个元素

        3).remove(): 从迭代器指向的collection中移除迭代器返回的最后一个元素(可选操作)

    LisIterator接口继承了Iterator接口

 

15.5 Collections(集合框架工具类)

(示例: basic.demo15.CollectionsDemo)

    此类完全由在collection上进行操作或返回collection 的静态方法组成. 它包含在collection上操作的多态算法, 即"包装器", 包装器返回由指定collection支持的新collection, 以及少数其他内容

表: Collections工具类方法

方法(均为static静态方法)	说明
<T extends Comparable<? super T>> void sort(List<T> list)	根据元素的自然顺序, 对指定列表按升序进行排序
<T> void sort(List<T> list, Comparator<? super T> c)	根据指定比较器产生的顺序对指定列表进行排序
<T> int binarySearch(List<? extends Comparable<? super T>> list, T key)	使用二分搜索法搜索指定列表, 以获得指定对象
<T> int binarySearch(List<? extends T> list, T key, Comparator<? super T> c)	使用二分搜索法搜索指定列表, 以获得指定对象
void reverse(List<?> list)	反转指定列表中元素的顺序
void shuffle(List<?> list)	使用默认随机源对指定列表进行置换
void shuffle(List<?> list, Random rnd)	使用指定的随机源对指定列表进行置换
void swap(List<?> list, int i, int j)	在指定列表的指定位置处交换元素
<T> void fill(List<? super T> list, T obj)	使用指定元素替换指定列表中的所有元素
<T> void copy(List<? super T> dest, List<? extends T> src)	将所有元素从一个列表复制到另一个列表
<T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll)	根据元素的自然顺序, 返回给定collection的最小元素
<T> T min(Collection<? extends T> coll, Comparator<? super T> comp)	根据指定比较器产生的顺序, 返回给定collection的最小元素
<T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)	根据元素的自然顺序, 返回给定collection的最大元素
<T> T max(Collection<? extends T> coll, Comparator<? super T> comp)	根据指定比较器产生的顺序, 返回给定collection的最大元素
void rotate(List<?> list, int distance)	根据指定的距离轮换指定列表中的元素
<T> boolean replaceAll(List<T> list, T oldVal, T newVal)	使用另一个值替换列表中出现的所有某一指定值
int indexOfSubList(List<?> source, List<?> target)	返回指定源列表中第一次出现指定目标列表的起始位置; 如果没有出现这样的列表, 则返回 -1
int lastIndexOfSubList(List<?> source, List<?> target)	返回指定源列表中最后一次出现指定目标列表的起始位置; 如果没有出现这样的列表, 则返回 -1
<T> Collection<T> unmodifiableCollection(Collection<? extends T> c)	返回指定collection的不可修改视图
<T> Set<T> unmodifiableSet(Set<? extends T> s)	返回指定set的不可修改视图
<T> SortedSet<T> unmodifiableSortedSet(SortedSet<T> s)	返回指定有序set的不可修改视图
<T> NavigableSet<T> unmodifiableNavigableSet(NavigableSet<T> s)
<T> List<T> unmodifiableList(List<? extends T> list)	返回指定列表的不可修改视图
<K,V> Map<K,V> unmodifiableMap(Map<? extends K, ? extends V> m)	返回指定映射的不可修改视图
<K,V> SortedMap<K,V> unmodifiableSortedMap(SortedMap<K, ? extends V> m)	返回指定有序映射的不可修改视图
<K,V> NavigableMap<K,V> unmodifiableNavigableMap(NavigableMap<K, ? extends V> m)
<T> Collection<T> synchronizedCollection(Collection<T> c)	返回指定collection支持的同步(线程安全的)collection
<T> Set<T> synchronizedSet(Set<T> s)	返回指定set支持的同步(线程安全的)set
<T> SortedSet<T> synchronizedSortedSet(SortedSet<T> s)	返回指定有序 set 支持的同步(线程安全的)有序set
<T> NavigableSet<T> synchronizedNavigableSet(NavigableSet<T> s)
<T> List<T> synchronizedList(List<T> list)	返回指定列表支持的同步(线程安全的)列表
<K,V> Map<K,V> synchronizedMap(Map<K,V> m)	返回由指定映射支持的同步(线程安全的)映射
<K,V> SortedMap<K,V> synchronizedSortedMap(SortedMap<K,V> m)	返回指定有序映射支持的同步(线程安全的)有序映射
<K,V> NavigableMap<K,V> synchronizedNavigableMap(NavigableMap<K,V> m)
<E> Collection<E> checkedCollection(Collection<E> c, Class<E> type)	返回指定collection的一个动态类型安全视图
<E> Queue<E> checkedQueue(Queue<E> queue, Class<E> type)
<E> Set<E> checkedSet(Set<E> s, Class<E> type)	返回指定set的一个动态类型安全视图
<E> SortedSet<E> checkedSortedSet(SortedSet<E> s, Class<E> type)	返回指定有序set的一个动态类型安全视图
<E> NavigableSet<E> checkedNavigableSet(NavigableSet<E> s, Class<E> type)
<E> List<E> checkedList(List<E> list, Class<E> type)	返回指定列表的一个动态类型安全视图
<K, V> Map<K, V> checkedMap(Map<K, V> m, Class<K> keyType, Class<V> valueType)	返回指定映射的一个动态类型安全视图
<K,V> SortedMap<K,V> checkedSortedMap(SortedMap<K, V> m, Class<K> keyType, Class<V> valueType)	返回指定有序映射的一个动态类型安全视图
<K,V> NavigableMap<K,V> checkedNavigableMap(NavigableMap<K, V> m, Class<K> keyType, Class<V> valueType)
<T> Iterator<T> emptyIterator()
<T> ListIterator<T> emptyListIterator()
<T> Enumeration<T> emptyEnumeration()
<T> Set<T> emptySet()	返回空的set(不可变的)
<E> SortedSet<E> emptySortedSet()
<E> NavigableSet<E> emptyNavigableSet()
final <T> List<T> emptyList()	返回空的列表(不可变的)
final <K,V> Map<K,V> emptyMap()	返回空的映射(不可变的)
final <K,V> SortedMap<K,V> emptySortedMap()
final <K,V> NavigableMap<K,V> emptyNavigableMap()
<T> Set<T> singleton(T o)	返回一个只包含指定对象的不可变set
<T> List<T> singletonList(T o)	返回一个只包含指定对象的不可变列表
<K,V> Map<K,V> singletonMap(K key, V value)	返回一个不可变的映射, 它只将指定键映射到指定值
<T> List<T> nCopies(int n, T o)	返回由指定对象的n个副本组成的不可变列表
<T> Comparator<T> reverseOrder()	返回一个比较器, 它强行逆转实现了Comparable接口的对象collection的自然顺序
<T> Comparator<T> reverseOrder(Comparator<T> cmp)	返回一个比较器, 它强行逆转指定比较器的顺序
<T> Enumeration<T> enumeration(final Collection<T> c)	返回一个指定collection上的枚举
<T> ArrayList<T> list(Enumeration<T> e)	返回一个数组列表, 它按返回顺序包含指定枚举返回的元素
int frequency(Collection<?> c, Object o)	返回指定collection中等于指定对象的元素数
boolean disjoint(Collection<?> c1, Collection<?> c2)	如果两个指定collection中没有相同的元素, 则返回true
<T> boolean addAll(Collection<? super T> c, T... elements)	将所有指定元素添加到指定collection中
<E> Set<E> newSetFromMap(Map<E, Boolean> map)	返回指定映射支持的 set
<T> Queue<T> asLifoQueue(Deque<T> deque)	以后进先出(Lifo) Queue的形式返回某个Deque的视图

 

 

 

转载于:https://my.oschina.net/vwFisher/blog/2209599