一、容器

• 容器包含集合以及数组，是用来保存对象的引用
• 数组：固定长度的，保存基本类型的字面量和引用类型的引用
• 集合：可变长度，保存饮用类型的引用

1. 集合

• 集合的范型：可以存储与定义的类及其子类
• 创建时： 使用向上转型的方式，方便后续代码修改具体的实现类
• 创建时：如果要使用到具体类的某些方法时候，不要采用向上转型
• 容器重写了toString，提供默认的输出方式

2. 常见方法

    private static void method01() {
        /*Arrays:
         * 1. 参数为一个可变参数
         * 2. 返回值：名字为ArrayList的类，是 Arrays的静态内部类
         * 3. 得到的list不能add或者remove，因为内部类中没有实现,
         *    UnsupportedOperationException*/
        List<String> stringList = Arrays.asList("FIRST", "SECOND", "THIRD");
        List<Integer> integerList = Arrays.asList(new Integer[]{1, 23, 43});
        System.out.println(stringList);
    }

    private static void method02() {
        /*Collections.addAll()
         * 1. 参数1： 集合， 参数2： 可变参数
         * 2. 返回值为是否添加成功, 只要成功添加一个元素，结果就为true
         * 3. 向参数1中的集合，添加一定的元素*/
        Collection<String> stringList = new HashSet<>();
        stringList.add("FIRST");
        stringList.add("SECOND");
        boolean b = Collections.addAll(stringList, "FOURTH", "FIVE", "FIRST");
        System.out.println(b);
        System.out.println(stringList);
    }

    private static void method03() {
        Collection<String> stringList = new HashSet<>();
        stringList.add("FIRST");
        stringList.add("SECOND");

        Collection<String> secondList = new HashSet<>();
        stringList.add("first");
        stringList.add("second");
        /* Collection.addAll()
        *  1. 合并两个集合*/
        boolean b = stringList.addAll(secondList);
    }

3. List

• ArrayList: 随机访问快，中间插入慢
• LinkedList: 随机访问慢，中间插入快
• 并不代表哪个一定好，除非成为性能瓶颈，否则不要优化

4. 迭代器

• 一种设计模式，不关系容器的具体类型，只关系容器内部保存的数据

/*不关心容器的类型，而只关心容器内存储的数据
     * 迭代器统一了对容器的访问方式*/
    private static <E> void method01(Collection<E> collection) {
        /*获取到一个迭代器*/
        Iterator iterator = collection.iterator();

        while (iterator.hasNext()) {
            E next = (E) iterator.next();
            System.out.println(next);
            /*将集合中的元素移除*/
            iterator.remove();
        }

        System.out.println(collection);
    }

    /*ListIterator: 继承Iterator，可以两边进行遍历*/
    private static <E> void method02(List<E> list) {
        ListIterator<E> iterator = list.listIterator();

        while (iterator.hasNext()) {
            E next = iterator.next();
            System.out.println(next);
        }

        while (iterator.hasPrevious()) {
            E previous = iterator.previous();
            System.out.println(previous);
        }
    }

5. Stack

• FILO: 可以通过Stack来实现一个队列

package com.erick;

import java.util.Stack;

/*用栈实现队列
 * 1. 用两个栈来实现一个队列
 * 2. 输入栈，输出栈，栈：可以用jdk中提供的stack类*/
public class Demo03 {

}

class ErickQueue<E> {

    private Stack<E> inStack = new Stack<>();
    private Stack<E> outStack = new Stack<>();

    public ErickQueue() {
    }

    public void push(E e) {
        inStack.push(e);
    }

    public E pop(E e) {
        if (outStack.isEmpty()) {
            fromInToOut();
        }
        return outStack.pop();
    }

    /*peek: 返回队列开头的元素*/
    public E peek() {
        if (outStack.isEmpty()) {
            fromInToOut();
        }
        return outStack.peek();
    }

    /*empty:  判断队列是否为空*/
    public Boolean empty() {
        if (inStack.isEmpty() && outStack.isEmpty()) {
            return true;
        }

        return false;
    }

    private void fromInToOut() {
        for (E e : inStack) {
            outStack.push(e);
        }
    }

}

6. Set

• Set就是Collection, 没有增加任何新的功能
• HashSet: 使用散列链表，没有顺序
• TreeSet: 使用红黑树，带顺序

7. Queue

• FIFO
• LinkedList可以作为 Queue 的具体实现