共计 4585 个字符，预计需要花费 12 分钟才能阅读完成。
汇合的顶层接口，不能被实例化
a) 根接口 Collection
i. 罕用子接口
1. List
实现类：ArrayList、Vector、LinkedList
2. Set
实现类：HashSet、TreeSet
b) 增加性能
i. boolean add(object obj) 增加一个元素
ii. boolean addAll(Collection c) 将汇合 c 的全副元素增加到原汇合元素后返回 true
iii. 增加性能永远返回 true
c) 删除性能
i. void clear(); 移除所有元素
ii. boolean remove(Object o) 移除一个元素
iii. boolean removeAll（Collection c）移除一个汇合的元素，只有有一个被移除就返回 true，扭转原汇合，删除原汇合中和 c 中雷同的元素
iv. 删除性能只有删除胜利后才返回 true
d) 判断性能
i. boolean contain(object o) 判断汇合中是否蕴含指定的元素。
ii. boolean containsAll(Collection c)判断原汇合中是否蕴含指定汇合 c 的所有元素，有则 true，
iii. boolean isEmpty()判断汇合是否为空
e) 获取性能
i. Iterator iterator() 迭代器，汇合的专用形式，实现遍历的性能
ii. Object next() 获取以后元素，并挪动到下一个地位
iii. boolean hasNext() 判断此地位是否有元素
iv. 迭代器遍历实例在上面
f) 长度性能
i. int size() 元素的个数
ii. 数组和字符串中都是 length() 办法获取元素个数，汇合中是 size()办法
因为 object 包含汇合、字符串、数组，所以其不能间接用 length 办法。
g) 交加性能 boolean retainAll(Collection c)
两个汇合交加的元素给原汇合，并判断原汇合是否扭转，扭转则 true，不变则 false
h) 把汇合转换为数组
i. Object [] toArray()
1、List 汇合
Collection 汇合的子类
特点：
a) 有序（存储和取出的元素程序统一），可反复
b) 特有性能
i. 增加性能
void add(int index,Object element) 在指定地位增加元素（原索引处的元素后延）
ii. 获取性能
Object get(int index) 获取指定地位的元素
iii. 列表迭代器
1. ListIterator listIterator() List 汇合特有的迭代器
2. Iterator 迭代器的子类，所以其能够用 Iterator 中的 boolean hasNext()、Object next() 办法
3. 特有的办法：
a) Object previous () 返回此处地位的前一个的元素，并挪动到前一个地位。
b) boolean hasPrevious()判断此处的前一个地位是否有元素
c) 逆向遍历必须先正向遍历使指针指到前面地位能力应用（应用意义不大）
4. 迭代器遍历元素时不能间接通过汇合批改元素，怎么办？
a) 迭代器批改元素
i. List 迭代器有批改办法，Collection 中的迭代器没有
ii. 通过迭代器中 add(object obj) 办法增加，跟在方才迭代元素前面
b) 通过汇合遍历元素，并用汇合批改元素（for 循环遍历）
i. 通过汇合中 add(object obj) 办法增加，跟在汇合最初面
5. 迭代器遍历实例实例在上面给出
iv. 删除性能
Object remove(int index) 依据索引删除指定的元素，并返回删除的元素
v. 批改性能、
Object set(int index,Object element) 依据索引批改元素，返回被批改的元素
vi. 数组转成汇合
1. public static List asList(T… a)，返回类型为 List 类型
2. a 为汇合，此处的… 代表可变参数，也就是 a 的数组元素个数可变
3. 此办法是 Arrays 类中的静态方法
4. 数组转变为汇合，本质还是数组须要保障长度不变，所以不反对增删汇合元素，能够批改元素
c) List 子类的特点：
i. ArrayList:
1. 底层数据结构是数组，查问快、增删慢
2. 线程不平安，效率高
ii. Vector：
1. 底层数据结构是数组，查问快，增删慢
2. 线程平安，效率底
iii. LinkedList：
1. 底层数据结构是链表，查问慢，增删快
2. 线程不平安，效率高
1.1、Vector 汇合特有的特点
a) 增加性能
i. public void addElement(Object obj)
b) 获取性能
i. public Object elementAt(int index)
ii. public Enumeration elements ()
1. 也是用来遍历汇合
2. boolean hasMoreElements()
3. Object nextElement()
4. 根本不必这个，都是间接用下面的迭代器实现遍历
1.2、LinkedList 汇合的特有性能
a) 增加性能
i. public void addFirst(Object e)
ii. public void addLast(Object e)
b) 获取性能
i. public Object getFirst()
ii. public Object getLast()
c) 删除性能
i. public Object removeFirst()
ii. public Object removeLast()
2、Set 汇合
a) 无序（存储和取出程序不统一，有可能会统一），然而元素惟一，不能反复
b) b) 实现类
i. HashSet
1. 底层数据是哈希表
2. 通过两个办法 hashCode() 和 equals()保障元素的唯一性，XM 外汇交易 xmchina.net.cn 办法主动生成
3. 子类 LinkedHashSet 底层数据结构是链表和哈希表，由链表保障元素有序，
由哈希表保障元素惟一。
ii. TreeSet
1. 底层数据是红黑二叉树
2. 排序形式：天然排序、比拟器排序
3. 通过比拟返回值是否为 0 来保障元素的唯一性。
2.1、HashSet 类：
a) 不保障 set 的迭代程序，
b) 当存储对象时须要重写 equals（）和 hashCode（）办法（能够用 Eclipse 主动生成此办法）
2.1.1、LinkedHashSet 类
a) HashSet 的子类
b) 可预知的迭代程序，底层数据结构由哈希表和链表组成
i. 哈希表：保障元素的唯一性
ii. 链表：保障元素有序（存储和取出程序统一）
2.2、TreeSet 类
a) 可能保障元素唯一性（依据返回值是否是 0 来决定的），并且依照某种规定排序
i. 天然排序，无参构造方法（元素具备比拟性）
依照 compareTo() 办法排序，让须要比拟的元素所属的类实现天然排序接口 Comparable，
并重写 compareTo()办法
ii. 1. 让汇合的构造方法接管一个比拟器接口的子类对象（compareator）
（此处的 Comparator 为接口，须要写一个接口实现类，在实现类中重写 compare() 办法，
并在这里创立接口实现类的对象，能够用匿名外部类来创立实现类对象）
b) 底层是自均衡二叉树构造
i. 二叉树有前序遍历、后序遍历、中序遍历
ii. TreeSet 类是依照从根节点开始，依照从左、中、右的准则依此取出元素
c) 当应用无参构造方法，也就是天然排序，须要依据要求重写 compareTo() 办法，这个不能主动生成
3、针对 Collection 汇合咱们应该怎么应用
a) 是否元素惟一
i. 是：Set
1. 是否排序
a) 是：TreeSet
b) 否：HashSet
如果不晓得用哪个 Set 就用 HashSet
ii. 否：List
1. 是否对安全性有要求
a) 是：Vector
b) 否：
查问多：ArrayList
增删多：LinkedList
如果不晓得用哪个 List 用 ArrayList
如果晓得是用汇合但不晓得用哪个用 ArrayList
二、Collection 汇合和 List 汇合迭代器遍历实例
package test10_collecton;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
//Collection 汇合中的办法，子集合都能够用
// Iterator<E> iterator() 迭代器，汇合的专用形式子集合都能够用
// Object next() 获取以后元素，并挪动到下一个地位
// boolean hasNext() 判断此地位是否有元素
//List 汇合中的办法
// void add(int index,Object element) 在指定地位增加元素（原索引处的元素后延）
// Object get(int index)获取指定地位的元素
//list 迭代器中的特有办法
// Object previous () 返回此处地位的前一个的元素，并挪动到前一个地位。
// boolean hasPrevious()判断此处的前一个地位是否有元素
public class InteratoeDemo {
public static void main(String[] args) {
//Collection 汇合的遍历
Collection c=new ArrayList();
c.add("zfliu");
c.add("18");
c.add("java");
Iterator i=c.iterator();
while(i.hasNext()) {
// 向下转型
String s=(String) i.next();
System.out.println(s);
}
System.out.println("-----------------");
//List 汇合的遍历
List l=new ArrayList();
l.add(0,"zfliu");
l.add(1,"18");
l.add(1,"java");
ListIterator li=l.listIterator();
// 后向遍历
while(li.hasNext()) {String s=(String)li.next();
System.out.println(s);
}
System.out.println("-----------------");
// 前向遍历
while(li.hasPrevious()) {String s=(String)li.previous();
System.out.println(s);
}
System.out.println("-----------------");
//get 办法遍历
for(int x=0;x<l.size();x++) {String s=(String)l.get(x);
System.out.println(s);
}
}}