一、集合架构图

二、Collection接口

Collection集合的遍历
迭代器：Iterater

方法名称	备注
Iterater Iterater()	返回在此collection的元素上进行迭代的迭代器
boolean hasNext()	如果有元素可以迭代，返回true，否则返回false
E next()	返回迭代的下一个元素

Collection<String> collection = new ArrayList<String>();
collection.add("test01");
collection.add("test02");
collection.add("test03");
collection.add("test04");
Iterator iterator = collection.iterator();
while (iterator.hasNext()){
	System.out.println(iterator.next());
}

手写Iterator迭代器的hasNext方法和next方法：

public class TestIterator {
    private List list;
    
    /**
     * @param list
     */
    public TestIterator(List list){
        this.list = list;
    }

    //计数器 初始值为0
    private int count = 0;

    /**
     * 手写 next方法
     * @return
     */
    public Object next(){
        if(list == null){
            throw new TestException("list is null");
        }
        if(count>=list.size()){
            throw new TestException("无法向下获取元素了");
        }
        return list.get(count++);
    }

    /**
     * 手写 hasNext方法
     * @return boolean 
     */
    public boolean hasNext(){
        return count != list.size();
    }
}

> 三、List接口：

（1）有序集合：存储和取出的元素顺序一致，可以精确控制集合中每个元素，可以通过索引访问元素，并搜索集合中的元素。
（2）可重复：存放的数据可以重复。
（3）子类：

• ArrayList：底层是基于数组结构来实现的；
• LinkedList：底层是基于链表结构来实现的。

三、ArrayList类

1. ArrayList的特点

ArrayList是基于数组结构来实现的。
ArrayList根据index下标查询get(index)、修改set(index, e)效率非常高，增加add(e)、删除remove(index)效率非常低。
ArrayList存放的数据可以重复，存入数据保证有序性。
ArrayList不是线程安全的。
ArrayList类是一个可以动态修改的数组，它没有固定长度.
ArrayList类位于java.util包中。

2. ArrayList常见的方法

方法名称	备注
public boolean add(E e)	将元素插入到arraylist中
public boolean add(int index, E e)	将元素插入到指定位置的arraylist中
public E remove(int index)	删除ArrayList里的单个元素
public E set(int index, E element)	替换ArrayList中指定索引的元素
public E get(int index)	通过索引值获取ArrayList中的元素
public int size()	返回Arraylist里元素数量

eg：

List<String> arrayList = new ArrayList<String>();
//添加元素1
arrayList.add("test01");
arrayList.add("test02");
//添加元素2
arrayList.add(2, "text03");
//删除元素
arrayList.remove(1);
//替换元素
arrayList.set(0,"test011");
//元素数量
arrayList.size();

3. ListItertor迭代器

方法名称	备注
ListItertor listIterator()	返回在此list的元素上进行迭代的迭代器
boolean hasNext()	从前往后，如果有元素可以迭代，返回true，否则返回false
boolean hasPrevious()	从后往前，如果有元素可以迭代，返回true，否则返回false
E next()	从前往后，返回迭代的下一个元素
E previous()	从后往前，返回迭代的下一个元素

public class Test02 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("test01");
        list.add("test02");
        list.add("test03");
        ListIterator listIterator = list.listIterator();
        //从前往后遍历
        while (listIterator.hasNext()){
            System.out.println(listIterator.next());
        }
        //从后往前遍历
        while (listIterator.hasPrevious()){
            System.out.println(listIterator.previous());
        }
    }
}

4. 增强for循环

int[] arrInt = {60,88,99,10};
for(int arr:arrInt){
	System.out.println(arr);
}
System.out.println("---------------------");
List<String> list = new ArrayList<String>();
list.add("test01");
list.add("test02");
list.add("test03");
list.add("test04");
for(String arr:list){
	System.out.println(arr);
}

5. Arrays.asList方法
   Arrays.asList方法可以创建集合，但创建的集合时不能够进行添加add()和删除remove()操作，集合的元素个数是不能够发生变化的，可以使用set()方法进行替换元素操作。

public static void main(String[] args) {
	//使用Arrays.asList方法创建的集合时不能够添加add()和删除remove()的
    List<String> stringList = Arrays.asList("qize", "chenq", "zeyu");
    System.out.println(stringList);
 }

6. ArrayList的效率问题

ArrayList 查询功能（get）：底层基于数组实现，根据index下标查询效率非常高，时间复杂度为O(1)。
ArrayList 新增功能（add）：ArrayList默认初始化数组容量为10，如果底层数组容量不够的情况下，就会触发动态扩容机制，效率非常低。
ArrayList 删除功能(remove)：会将删除后面的元素向前移动一位效率也非常低。
ArrayList 修改功能(set)：根据下标位置修改，效率非常高；根据元素修改，效率非常低。

7. ArrayList总结

（1）ArrayList 底层是基于数组实现的；
（2）ArrayList 底层数组初始化容量为10；
（3）ArrayList 每次扩容是原来的1.5倍；
（4）ArrayList 是线程不安全的；
（5）ArrayList 懒加载的形式去初始化容量，不调用add方法不会有容量

ArrayList 的 add()方法的实现：

（1）判断集合容量是否装得下；
（2）如果装不下则扩容，1.5倍创建新数组，将原来的数组的数据拷贝到新的数组中。

ArrayList 的 get()方法的实现：

（1）直接提供了根据index下标查询，效率非常高；

ArrayList 的 remove()方法的实现：

（1）查找到删除对于的index 下标位置+1到最后的元素值向前移动一位。

四、Vector类

1. Vector总结

（1）Vector 底层是基于数组实现的；
（2）Vector 底层数组初始化容量为10；
（3）Vector 每次扩容是原来的2倍；
（4）Vector 是线程安全的；
（5）Vector 直接通过构造函数去初始化容量，数组容量为10。

eg:

public class Test01 {
    public static void main(String[] args) {
        Vector<String> strings1 = new Vector<>();
        strings1.add("qize");
        //参数10为初始化容量=10，参数20为每次扩容20
        Vector<String> strings2 = new Vector<>(10,20);
    }
}

五、ArrayList 与Vector的异同

1. 相同点

（1）ArrayList 与 Vector 底层都是基于数组实现的；
（2）ArrayList 与 Vector 初始化数组容量都为10；
（3）ArrayList 与 Vector 都是List接口下的子类。

2. 不同点

（1）ArrayList 是线程不安全的，Vector 是线程安全的；
（2）ArrayList 每次扩容是原来的1.5倍，Vector 每次扩容是原来的2倍；
（3）ArrayList 懒加载的形式去初始化容量，不调用add方法不会有容量，Vector 直接通过构造函数去初始化容量，Vector 可以设置每次扩容的容量。