首先总结一下集合的体系：
集合 的体系：
------------| Collection 单例集合的根接口
----------------| List 如果是实现了List接口的集合类，具备的特点： 有序，可重复。
-------------------| ArrayList 底层是维护了一个Object数组实现的。 特点： 查询速度快，增删慢。
-------------------| LinkedList 底层是使用了链表数据结构实现的， 特点： 查询速度慢，增删快。
-------------------| Vector(了解即可) 底层也是维护了一个Object的数组实现的，实现与ArrayList是一样的，但是Vector是线程安全的，操作效率低。
----------------| Set 如果是实现了Set接口的集合类，具备的特点： 无序，不可重复。
-------------------| HashSet 底层是使用了哈希表来支持的，特点： 存取速度快.
-------------------| TreeSet 如果元素具备自然顺序 的特性，那么就按照元素自然顺序的特性进行排序存储。
Collection
首先我们先来看一下JAVA中util包中几个集合之间的继承或实现关系：
可以看出Collection是所有集合的源头（实现接口）。
因为Colleciton是接口，所以我们不能直接实现他，只能利用子类向上转型来实现它。
Collection c = new ArrayList();
一些简单的API代码:
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class CollectionDemo {
public static void main(String[] args) {
//集合 导包 全都是java.util包下的
//无序 可重复
//接口 向上转型特点 只能调用共有的属性和方法
Collection c1 = new ArrayList();
Collection c2 = new ArrayList();
c2.add(10);
c2.add(true);
c2.add(33.4);
c2.add("ddd");
//1.添加
c1.add(10);
c1.add(true);
c1.add(33.4);
c1.add("ddd");
//添加集合
c1.addAll(c2);
System.out.println(c1);
//2.清空全部元素
//c1.clear();
System.out.println(c1);
c1.add(33.4);
c1.add("ddd");
//3.移除单个元素
c1.remove("ddd");//移除里面的元素
//c1.removeAll(c2);//移除里面的集合
System.out.println(c1);
//4.判断此集合是否是空元素集合
System.out.println(c1.isEmpty());
//5.判断此元素是否存在集合中 有返回true
System.out.println(c1.contains(33.4));
//c1.containsAll(c)判断集合是否存在此集合中
//6.长度
System.out.println("集合长度："+c1.size());
//遍历 只要集合中发现了迭代器方法 都可以使用foreach （for增强） 去遍历集合
//1.foreach遍历 for(数组或集合数据类型 起个名字 ：数组名或集合名){输出起的这个名}
for(Object obj:c1) {
System.out.println(obj);
}
System.out.println("---------------------------------------");
//2.使用迭代器遍历集合
//得到迭代器
Iterator i1=c1.iterator();
//判断游标后面有没有元素 有就返回true
while(i1.hasNext()) {
//返回游标下一个元素 并把游标位置移动到下一个位置
System.out.println(i1.next());
}
//i1.hasNext()他返回的就是false
System.out.println("i2------------------------------");
//集合中有序无序 你要看他可不可以用下标访问元素
Iterator i2=c1.iterator();
while(i2.hasNext()) {
//返回游标下一个元素 并把游标位置移动到下一个位置
System.out.println(i2.next());
}
}
}
List
List和Collection相比，List是有序的集合，可以通过下标来索引。
其他的东西并不太特殊。
其中List的迭代器实现中，提供类listIterator()方法，下面总结了一下listIterator和Iterator两个迭代器不同的地方：
-
使用范围不同，Iterator可以应用于所有的集合，Set、List和Map和这些集合的子类型。而ListIterator只能用于List及其子类型。
-
ListIterator有add方法，可以向List中添加对象，而Iterator不能。
-
ListIterator和Iterator都有hasNext()和next()方法，可以实现顺序向后遍历，但是ListIterator有hasPrevious()和previous()方法，可以实现逆向（顺序向前）遍历。Iterator不可以。
-
ListIterator可以定位当前索引的位置，nextIndex()和previousIndex()可以实现。Iterator没有此功能。
-
都可实现删除操作，但是ListIterator可以实现对象的修改，set()方法可以实现。Iterator仅能遍历，不能修改。
下面是一些简单的API：
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
public class ListDemo {
public static void main(String[] args) {
List l1=new ArrayList<>();
//1.添加
l1.add("ddd");
l1.add(1);
l1.add("gggg");
l1.add(1);
l1.add(1, "张三");
System.out.println(l1);
//2.移除
System.out.println(l1.remove("gggg"));
System.out.println(l1);
//3.清空 长度 还有空集合判断 判断元素是否包含 跟collection一样的
//4.通过下标得到元素
System.out.println(l1.get(1));
//5 替换
l1.set(2, "李四");
//6 indexof 返回此元素第一次出现的下标值 （索引值） 没有-1 lastindexof 返回最后一次出现的下标值
System.out.println(l1.indexOf("李四"));
//遍历 for循环 foreach 迭代器
System.out.println("for循环--------------------");
for (int i = 0; i <l1.size(); i++) {
System.out.println(l1.get(i));
}
System.out.println("foreach---------------------");
//foreach
for(Object o1:l1) {
System.out.println(o1);
}
System.out.println("迭代器--------------------");
Iterator iterator = l1.iterator();
while(iterator.hasNext()) {
System.out.println(iterator.next());
}
System.out.println("列表迭代器-----------------");
//列表迭代器 正序
ListIterator listIterator = l1.listIterator();
while(listIterator.hasNext()) {
System.out.println(listIterator.next());
}
//倒序需要游标最后的时候使用打印才出内容
System.out.println("列表迭代器2-----------------");
ListIterator li2=l1.listIterator();
while(li2.hasNext()) {
System.out.println(li2.next());
}
System.out.println("倒序---------------------");
while(li2.hasPrevious()) {
System.out.println(li2.previous());
}
}
}
ArrayList和Vector
都是基于数组实现的 List 类，封装了一个动态的、允许再分配的 Object[] 数组，主要使用
initialCapacity 参数来设置该数组的长度，当添加的元素数量 过多的话，则 initialCapacity 会自动增
长，默认长度是 10。
有时候需要注意性能问题，如果向这两个集合中添加大量元素时，可用 ensureCapacity(int
minCapacity) 方法一次性地增加 initialCapacity，这样可以减少重分配的次数，提高新能。
它们也可以使用 ensureCapacity(int minCapacity) 和 trimToSize() 方法来重新分配 Object[] 数组。
Vector 是一个比较老旧的集合，是 ArrayList 的前身，有很多缺点，不建议使用。
ArrayList 是线程不安全的，如果多个线程访问&修改了 ArrayList 集合，就需要手动保证集合的同步
性。
Vector 是线程安全的，所以性能会比 ArrayList 稍低，哪怕是线程安全也不推荐使用。
public class ArrayListDemo2 {
public static void main(String[] args) {
ArrayList<String> aList=new ArrayList<String>();
aList.add("ddd");
aList.add("zhansgan");
for (String string : aList) {
System.out.println(string);
}
ArrayList aList2=new ArrayList<>();
aList2.add("dd");
aList2.add(2);
for (Object object : aList2) {
System.out.println(object);
}
//使用基本数据类型包装类 指定集合泛型
ArrayList<Integer> aList3=new ArrayList<>();
//迭代器
Iterator<String> i1=aList.iterator();
while(i1.hasNext()) {
System.out.println(i1.next());
}
//泛型除了可以在集合中使用之外 也可以在类和方法中使用
}
}
长度不变的集合（Arrays）
Arrays 类的 asList(Object... a) 静态方法，可以把一个数组或指定个数的对象转成一个 List 集合，这个集合
既不是 ArrayList 实现类的实例，也不是 Vector 实现类的实例，而是 Arrays 的内部类 ArrayList 的实
例。
Arrays.ArrayList 是一个固定长度的 List 集合，只能访问元素，不能添加和删除集合中的元素。
其源码如下：
@SafeVarargs
@SuppressWarnings("varargs")
public static <T> List<T> asList(T... a) {
return new ArrayList<>(a);
}
一些小demo代码：
import java.util.Arrays;
import java.util.List;
public class ArraysDemo {
public static void main(String[] args) {
//...在方法中书写 调用方法时候可以书写多个参数
//注意...必须放置到最后一个参数类型后面
//asList(T... a)
//返回的这个集合 长度不可变 不能添加不能删除
List<String> l1= Arrays.asList("张三","李四","王五");
System.out.println(l1);
l1.add("钱六");
System.out.println(l1);
// show(1,3,4);
}
// public static void show(Double b,int... a) {
//
// }
}