Java——集合

定义

Java集合类存放在java.util包中，是一个用来存放对象的容器。

注意：

1. 集合只能存放对象。比如你存入一个int型数据放入集合中，其实它是自动转换成Integer类后存入的，Java中每一种基本数据类型都有对应的引用类型。
2. 集合存放的都是对象的引用，而非对象本身。所以我们称集合中的对象就是集合中对象的引用。对象本身还是放在堆内存中。
3. 集合可以存放不同类型，不限数量的数据类型。

背景

因为数组在存储多个数据方面的缺点:

1. —旦初始化以后，其长度就不可修改。
2. 数组中提供的方法非常有限，对于添加、删除、插入数据等操作，非常不便，同时效率不高。
3. 获取数组中实际元素的个数的需求，数组没有现成的属性或方法可用
4. 数组存储数据的特点:有序、可重复。对于无序、不可重复的需求，不能满足。

框架

|----Collection接口:单列集合，用来存储一个一个的对象
　　|----List接口:存储有序的、可重复的数据。实质就是一个动态“数组”
　　　　|----ArrayList、LinkedList、 Vector
　　|----Set接口:存储无序的、不可重复的数据，与高中所学的集合类似
　　　　|----HashSet、LinkedHashSet、 TreeSet
|----Map接口:双列集合，用来存储一对(key - value)一对的数据,类似于高中所学的函数。
　　|----HashMap、LinkedHashMap、TreeMap、HashtabLe、Properties

Collection接口

常用Collection方法

返回类型	方法	个人理解
boolean	add(E e)确保此集合包含指定的元素（可选操作）。	一般在实现类会被重载。
boolean	addAll(Collection<? extends E> c)将指定集合中的所有元素添加到此集合（可选操作）。
void	clear()从此集合中删除所有元素（可选操作）。
boolean	contains(Object o)如果此集合包含指定的元素，则返回 true 。	判断当前集合是否包含o,使用的是o所在类的equals()方法
boolean	containsAll(Collection<?> c)如果此集合包含指定 集合中的所有元素，则返回true。
boolean	equals(Object o)将指定的对象与此集合进行比较以获得相等性。
int	hashCode()返回此集合的哈希码值。
boolean	isEmpty()如果此集合不包含元素，则返回 true 。
Iterator<E>	iterator()返回此集合中的元素的迭代器。
default Stream<E>	parallelStream()返回可能并行的 Stream与此集合作为其来源。
boolean	remove(Object o)从该集合中删除指定元素的单个实例（如果存在）（可选操作）。	一般在具体实现类会被重载
boolean	removeAll(Collection<?> c)删除指定集合中包含的所有此集合的元素（可选操作）。	collection.retainAll(collection1):求collection与collection1的交集，并将交集赋值给collection。
default boolean	removeIf(Predicate<? super E> filter)删除满足给定谓词的此集合的所有元素。
boolean	retainAll(Collection<?> c)仅保留此集合中包含在指定集合中的元素（可选操作）。
int	size()返回此集合中的元素数。
default Spliterator<E>	spliterator()创建一个Spliterator在这个集合中的元素。
default Stream<E>	stream()返回以此集合作为源的顺序 Stream 。
Object[]	toArray()返回一个包含此集合中所有元素的数组。
<T> T[]	toArray(T[] a)返回包含此集合中所有元素的数组; 返回的数组的运行时类型是指定数组的运行时类型。

迭代器

主要用于遍历集合的元素（其实也可以用foreach增强型for循环遍历，其实质也是调用迭代器）。在Collection接口中有iterator()方法。
常见遍历集合的写法：

//hasNext():判断是否还有下一个元素
while(iterator.hasNext()){
//next():①指针下移②将下移以后集合位置上的元素返回
System.out.println(iterator.next());
}

List

List继承框架

|----Collection接口:单列集合，用来存储一个一个的对象
　　|----List接口:存储有序的、可重复的数据。–>“动态”数组,替换原有的数组
　　　　|----ArrayList:作为List接口的主要实现类，线程不安全的，效率高;底层使用Object[] elementData存储
　　　　|----LinkedList:对于频繁的插入、删除操作，使用此类效率比ArrayList高;底层使用双向链表存储
　　　　|----Vector:作为List接口的古老实现类;线程安全的，效率低;底层使用Object[] elementData存储

特点

1. 加入顺序与取出顺序一致，可重复
2. 支持索引
3. 实现类有 ArrayList LinkedList Vetor
4. 可以加入null，并且可以重复加入null

常用方法

返回值	方法
boolean	add(E e)将指定的元素追加到此列表的末尾（可选操作）。
void	add(int index, E element)将指定的元素插入此列表中的指定位置（可选操作）。
boolean	addAll(Collection<? extends E> c)按指定集合的迭代器（可选操作）返回的顺序将指定集合中的所有元素附加到此列表的末尾。
boolean	addAll(int index, Collection<? extends E> c)将指定集合中的所有元素插入到此列表中的指定位置（可选操作）。
void	clear()从此列表中删除所有元素（可选操作）。
boolean	contains(Object o)如果此列表包含指定的元素，则返回 true 。
boolean	containsAll(Collection<?> c)如果此列表包含指定 集合的所有元素，则返回true。
boolean	equals(Object o)将指定的对象与此列表进行比较以获得相等性。
E	get(int index)返回此列表中指定位置的元素。
int	hashCode()返回此列表的哈希码值。
int	indexOf(Object o)返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。
boolean	isEmpty()如果此列表不包含元素，则返回 true 。
Iterator<E>	iterator()以正确的顺序返回该列表中的元素的迭代器。
int	lastIndexOf(Object o)返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。
ListIterator<E>	listIterator()返回列表中的列表迭代器（按适当的顺序）。
ListIterator<E>	listIterator(int index)从列表中的指定位置开始，返回列表中的元素（按正确顺序）的列表迭代器。
E	remove(int index)删除该列表中指定位置的元素（可选操作）。
boolean	remove(Object o)从列表中删除指定元素的第一个出现（如果存在）（可选操作）。
boolean	removeAll(Collection<?> c)从此列表中删除包含在指定集合中的所有元素（可选操作）。

注意：remove方法在删除的是整数的时候，优先删除对应位置的元素。

如 
ArrayList list=new ArrayList();
list.add(1);
list.add(2);
list.add(3);
list.remove(2);
System.out.println(list);//输出【1,2】

ArrayList源码分析

底层特点：（JDK8的）

1. 数据由数组存储
2. 若未指定初始化大小，则默认为0，并且在第一次添加时扩容到10，之后若需再次扩容，则扩为之前的1.5倍。
3. 若指定初始化，则第一次添加时不做扩容，后续扩容与 2 一致
4. 线程不安全，多线程不建议使用，但效率高

JDK7（类似于懒汉式）
ArrayList list=new ArrayList（）;//底层默认初始化一个容量为10的数组
list.add();//如果此次的添加导致底层eLementData数组容量不够，则扩容。
//默认情况下，扩容为原来的容量的1.5倍，同时需要将原有数组中的数据复制到新的数组中。
//建议：在已知list的大小范围的时候，使用带参构造器

JDK8（类似于饿汉式）
ArrayList list=new ArrayList（）;//底层并没有创建一个容量为10的数组
//直到使用add()方法的时候才创建数组

Vector源码分析

底层特点：（JDK8）

1. 数据由数组存储
2. 若未指定初始化大小，则默认为0，并且在第一次添加时扩容到10，之后若需再次扩容，则扩为之前的2倍。
3. 若指定初始化，则第一次添加时不做扩容，后续扩容与 2 一致
4. 线程同步，线程安全，效率不如ArrayList

LinkedList源码分析

特点：

1. 实现了双向链表和双端队列的特点
2. 实现添加任意元素，包括null，可以重复
3. 线程不安全，没有实现同步
4. 添加、删除效率高

机制：

1. 底层由一个双向链表存储数据
2. 维护两个属性first和last，分别指向首结点和尾结点
3. 每个节点里又维护prev、next、item三个属性，prev指向前一个节点，next指向下一个节点

LinkedList list=new LinkedList();//底层是双向链表，内部声明了Node类型的first和last属性
								//默认为null
list.add(e);   					//该方法会将e创建成Node对象  

ArrayList、LinkedList的选择

1. 如果改查操作多，选择ArrayList
2. 如果增删操作多，选择LinkedList

Set

Set的继承框架

|-----Collection接口:单列集合，用来存储一个一个的对象
　　|----Set接口:存储无序的、不可重复的数据–>高中讲的集合”
　　　|----HashSet:作为Set接口的主要实现类;线程不安全的;可以存储null值
　　　　　l----LinkedHashSet:作为HashSet的子类;遍历其内部数据时，可以按照添加的顺序遍历
　　　|----TreeSet:可以按照添加对象的指定属性，进行排序。

Set的特点

set:存储无序的、不可重复的数据以Hashset为例说明:

1. 无序性:不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序添加，而是根据数据的哈希值
2. 不可重复性:保证添加的元素按照equals()判断时，不能返回true.即:相同的元素只能添加一个.不允许重复元素，最多一个null。
3. 存放和取出的顺序没有关系

HashSet

添加元素的过程

我们向HashSet中添加元素a,首先调用元素α所在类的hashCode()方法，计算元素a的哈希值，此哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置（即为:索引位置），判断数组此位置上是否已经有元素:
　　如果此位置上没有其他元素，则元素α添加成功。—>情况1
　　如果此位置上有其他元素b(或以链表形式存在的多个元素），则比较元素a与元素b的hash值:
　　　　如果hash值不相同，则元素α添加成功。—>情况2
　　　　如果hash值相同，进而需要调用元素α所在类的equlas()方法:
　　　　　　equals()返回true,元素α添加失败
　　　　　　equals()返回false,则元素α添加成功。—>情况3
　　　　　　
对于添加成功的情况2和情况3而言: 元素a与已经存在指定索引位置上数据以链表的方式存储
jdk 7 ∶元素α放到数组中，指向原来的元素。
jdk 8 ∶原来的元素在数组中，指向元素a
总结:七上八下

Set难点

set是按序列添加，按序列删除的。
序列：序列受equals（）和hashCode（）共同影响

HashSet set=new HashSet();
person p1=new person("AA",12);
person p2=new person("BB",13);
set.add(p1);//按序列存储，序列受equals（）和hashCode（）共同影响
set.add(p2);
System.out.println(set);
//      [person{name='AA', age=12}, person{name='BB', age=13}]
p1.setName("CC");
set.remove(p1);//remove()是按序列来删除的，p1更改之前和更改之后的序列不一样，所以并不会删除到真实的p1
System.out.println(set);
//      [person{name='CC', age=12}, person{name='BB', age=13}]
person p3=new person("CC",12);
set.add(p3);//p3在底层数组对应的下标目前根据hashCode()计算并没有值，可以添加
System.out.println(set);
//      [person{name='CC', age=12}, person{name='CC', age=12}, person{name='BB', age=13}]
person p4=new person("AA",12);
set.add(p4);//p4根据equals()判断并不存在相同的值，可以添加
System.out.println(set);
//      [person{name='CC', age=12}, person{name='CC', age=12}, person{name='AA', age=12}, person{name='BB', age=13}]

LinkedHashSet

特点：

1. 是HashSet的子类
2. 底层是LinkedHashMap实现**(数组+双链表)**
3. 根据元素的hashCode值来决定元素的存储位置，同时使用链表维护元素的次序，使得元素看起来插入有序
4. 不允许重复值

TreeSet

特点：

1. 自动排序：TreeSet中的元素可以自动按照升序或降序进行排序。如果在构造TreeSet对象时没有传入Comparator对象，则使用元素默认排序规则，否则使用自定义的排序规则。基于红黑树数据结构， TreeSet通过比较元素大小来自动排序。
2. TreeSet内部实现采用一种名为红黑树的自平衡二叉查找树数据结构。通过该数据结构，TreeSet能够对存储的元素进行高效的、对数时间复杂度的查找、插入及删除操作。

Map接口

Map继承树

l----Map:双列数据，存储key-value对的数据—类似于高中的函数: y = f(x)
　　|----HashMap:作为Map的主要实现类;线程不安全的，效率高;存储null的key和value
　　　　|----LinkedHashMap:保证在遍历map元素时，可以按照添加的顺序实现遍历。
　　　　　　原因:在原有的HashMap底层结构基础上，添加了一对指针，指
　　　　　　向前一个和后一个元素。对于频繁的遍历操作，此类执行效率
　　　　　　高于HashMap 。
　　|----TreeMap:保证按照添加的Rey-value对进行排序，实现排序遍历。此时考虑key的自然排序或定制排序
　　　　　　底层使用红黑树
　　|----Hashtable:作为古老的实现类;线程安全的，效率低;不能存储nuLl的key和value
　　　　|----Properties:常用来处理配置文件。key和value都是String类型
　　　　
HashMap的底层:数组+链表(jdk7及之前)
　　　　　　　　数组+链表+红黑树(jdk 8)

Map结构的理解

Map中的key:无序的、不可重复的，使用Set存储所有的key —> key所在的类要重写equals() 和hashCode()(以HashMap为例)

Map中的value:无序的、可重复的，使用Collection存储所有的value —>value所在的类要重写equals()
一个键值对: key-value构成了一个Entry对象。

Map中的entry:无序的、不可重复的，使用set存储所有的entry

HsahMap

特点：

1. key不能重复，但是值可以重复，允许null键和null值
2. 如果添加相同的key，则会覆盖原来的key-val，等同于修改（key不会替换，val会替换）
3. 与HashSet一样，不能保证映射的顺序，因为底层是以hash表的方式来存储的（JDK8 底层: 数组+链表+红黑树）
4. 没有实现同步，因此线程不安全，方法没有做同步互斥的操作

HashMap的底层实现(JDK7为例)

HashMap map = new HashMap( ):
在实例化以后，底层创建了长度是16的一维数组Entry[ ] table。

map.put( key1 , value1):

1. 首先，调用key1所在类的hashCode()计算key1哈希值，此哈希值经过某种算法计算以后，得到在Entry数组中的存放位置。
   1. 如果此位置上的数据为空，此时的key1-value1添加成功。----情况1
   2. 如果此位置上的数据不为空，(意味着此位置上存在一个或多个数据(以链表形式存在)),比较key1和已经存在的一个或多个数据的哈希值:
      1. 如果key1的哈希值与已经存在的数据的哈希值都不相同，此时key1-value1添加成功。----情况2
      2. 如果key1的哈希值和已经存在的某一个数据(key2-value2)的哈希值相同，继续比较:调用key1所在类的equals(key2)
         1. 如果equals()返回false:此时key1-value1添加成功。----情况3
         2. 如果equals()返回true:使用value1替换value2。

补充:

关于情况2和情况3：此时key1-value1和原来的数据以链表的方式存储。

在不断的添加过程中，会涉及到扩容问题，默认的扩容方式:扩容为原来容量的2倍，并将原有的数据复制过来。扩容机制（特别注意：并不是容量满了才扩容，而是根据加载因子（默认为0.75）来决定）

注意：jdk7的扩容是在大于12就会扩容，而不是等到大于16才扩容。

jdk8与jdk7对比

1. new HashMap():底层没有创建一个长度为16的数组
2. jdk8底层的数组是:Node[ ].而非Entry[]
3. 首次调用put()方法时，底层创建长度为16的数组
4. jdk7底层结构只有:数组+链表。jdk8中底层结构:数组+链表+红黑树。

当数组的某一个索引位置上的元素以链表形式存在的数据个数>8 且 当前数组的长度>64 时，此时此索引位置上的所有数据改为使用红黑树存储。

HashTable

特点：

1. 存放的元素是键值对：即K-V
2. hashtablel的键和值都不能为null,否则会抛出NullPointerException
3. hashTable使用方法基本上和HashMap一样
4. hashTable是线程安全的(synchronized),hashMap是线程不安全的

Properties

特点：

1. Properties类继承自Hashtable类并且实现了Map接口，也是使用一种键值对的形式来保存数据。
2. 使用特点和Hashtable类似
3. Properties还可以用于从xxx.properties文件中，加载数据到Properties类对象，并进行读取和修改

Map中定义的方法

返回值	方法以及描述
void	clear()从该Map中删除所有的映射（可选操作）。
boolean	containsKey(Object key)如果此映射包含指定键的映射，则返回 true 。
boolean	containsValue(Object value)如果此Map将一个或多个键映射到指定的值，则返回 true 。
Set<Map.Entry<K,V>>	entrySet()返回此Map中包含的映射的Set视图。
boolean	equals(Object o)将指定的对象与此映射进行比较以获得相等性。
V	get(Object key)返回到指定键所映射的值，或 null如果此映射包含该键的映射。
int	hashCode()返回此Map的哈希码值。
boolean	isEmpty()如果此Map不包含键值映射，则返回 true 。
Set<K>	keySet()返回此Map中包含的键的Set视图。
V	put(K key, V value)将指定的值与该映射中的指定键相关联（可选操作）。
void	putAll(Map<? extends K,? extends V> m)将指定Map的所有映射复制到此映射（可选操作）。
V	remove(Object key)如果存在（从可选的操作），从该Map中删除一个键的映射。
int	size()返回此Map中键值映射的数量。
Collection<V>	values()返回此Map中包含的值的Collection视图。

Collections集合工具类

Collections的静态方法

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

注意：

//注意：void copy（List dest,List src）的使用
List dest=Arrays.asList(new Object[src.size()])
Collections.copy(dest,list)

附带：
面试题:ArrayList、LinkedList、 Vector三者的异同?

同：三个类都是实现了List接口，存储数据的特点相同:存储有序的、可重复的数据
不同：同上
参考链接：什么是Java集合？