李斯特的三个儿子（ArrayList Vector LinkedList）

ArrayList 底层数据结构是数组，查询块，增删慢 线程不安全，效率高

ArrayList 你不定义我初始容量就为10的空列表；

方法

1. protected void removeRange ( int fromIndex, int toIndex)
   从列表中删除所有的元素的索引 fromIndex之间，包容性，和 toIndex，独家。
   void replaceAll (UnaryOperator < E > operator)
   用将运算符应用到该元素的结果替换此列表中的每个元素。

2. void forEach (Consumer < ? super E > action)
   执行特定动作的每一个元素的 Iterable直到所有元素都被处理或操作抛出异常。

3. void sort (Comparator < ? super E > c)
   分类列表使用提供的 Comparator比较元素。
   例子：

***匿名内部类 ***别忘了

list.forEach(new Consumer() {
            @Override
            public void accept(Object o) {
                System.out.println(o);
            }
        });
  list.sort(new Comparator() {
            @Override
            public int compare(Object a, Object b) {
                Integer aa = (Integer) a;//向下转型  别忘了
                Integer bb = (Integer) b;//向下转型  别忘了
                return (aa - bb);
            }
        });

经典犯错的地方

interface Inter {
    void show();
}

class Outer {
    //补齐代码
   ***public static Inter method(){
       return new Inter() {
           @Override
           public void show() {
               System.out.println("helloword");
           }
       };***
   }
}

class OuterDemo {
    public static void main(String[] args) {

        ***Outer.method().show(); //输出HelloWorld***
    }
}

Vector 底层数据结构也是数组，增删慢 ，查询块，线程安全，效率低

/*  void addElement (E obj)
        将指定的组件添加到此向量的末尾，将其大小增加 1。
*/

      /*  E elementAt ( int index)
        返回指定索引处的组件。

*/
        Object o = vector.get(0);
        Object o1 = vector.elementAt(0);

     /*   E firstElement ()
        返回此向量的第一个组件（位于索引 0)处的项）。

        E lastElement ()
        返回此向量的最后一个组件。


        void removeAllElements()
          从此向量中移除全部组件，并将其大小设置为零。 */

     // vector.clear(); 
     //Vector 自带的迭代器 Enumeration
        Enumeration elements = vector.elements();
        while (elements.hasMoreElements()){
            Object o2 = elements.nextElement();
            System.out.println(o2);
        }

LinkedList 底层数据结构是链表，查询慢，增删快 ，线程 不安全，效率高

linkedList.addLast
linkedList.addFirst //往最前面加 linkedList.addFirst(600); //往最前面加

// linkedList.removeFirst();
       // linkedList.removeLast();

      /*  E peek ()
        获取但不移除此列表的头（第一个元素）。*/
        Object peek = linkedList.peek();
        System.out.println(peek);

      /*  E poll ()
        获取并移除此列表的头（第一个元素）*/

        Object poll = linkedList.poll();

模拟栈数据结构

 public static void main(String[] args) {
       /* A:
        案例演示:
        需求：请用LinkedList模拟栈数据结构的集合，并测试*/
       //栈的数据结构是先进后出，后进先出
      /*  ArrayList list = new ArrayList();
        list.add(100);

        list.add(400);

        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        */

        MyList myList = new MyList();
        myList.addEle(100);
        myList.addEle(200);
        myList.addEle(300);

        Object ele = myList.getEle();
        System.out.println(ele);
        ele = myList.getEle();
        System.out.println(ele);

        ele = myList.getEle();
        System.out.println(ele);
    }