Java集合框架之Vector与LinkedList_vector和linkedlist java

数据结构之栈和队列，数组和链表

  数据结构：数据存储的格式
  常见的数据结构：栈，队列，数组，链表，树 哈希表
  栈：先进的后出，后进的先出 弹夹
  队列：先进的先出
  数组：有索引，查询块，删除慢
  链表：多个节点，像铁链一样连接起来，查询慢，增删块
  List的三个子类的特点
  ArrayList:
  底层数据结构是数组，查询快，增删慢。
  线程不安全，效率高。
  Vector:
  底层数据结构是数组，查询快，增删慢。
  线程安全，效率低。
  LinkedList:
  底层数据结构是链表，查询慢，增删快。
  线程不安全，效率高。

一、Vector

  1、概述
  可以实现可增长的对象数组，vector是同步的
  2、特有功能
  public void addElement(E obj) 将指定的组件添加到此向量的末尾，将其大小增加 1。
  public E elementAt(int index) 返回指定索引处的组件，此方法的功能与 get(int) 方法的功能完全相同（后者是 List 接口的一部分）。

		Vector vector = new Vector();
        vector.addElement(100);
        vector.addElement(300);
        vector.addElement(1000);
        vector.add(500);
        vector.add(700);
        System.out.println(vector.elementAt(3));//输出500
1
2
3
4
5
6
7

  public Enumeration elements()返回此向量的组件的枚举。返回的 Enumeration 对象将生成此向量中的所有项。生成的第一项为索引 0 处的项，然后是索引 1 处的项，依此类推。

//遍历集合
		Vector vector = new Vector();
        vector.addElement(100);
        vector.addElement(300);
        vector.addElement(1000);
        vector.add(500);
        vector.add(700);
        Enumeration elements = vector.elements();
        while(elements.hasMoreElements()){
            Object obj = elements.nextElement();
            System.out.println(obj);
        }    
1
2
3
4
5
6
7
8
9
10
11
12

二、LinkedList

  1、概述

  List 接口的链接列表实现 , 此实现不是同步的，LinkedList 底层数据结构是链表，查询慢，增删快，线程不安装效率高
  2、特有功能
  public void addFirst(E e)及addLast(E e)

		LinkedList linkedList = new LinkedList();
        linkedList.add(100);
        linkedList.addFirst(200);
        linkedList.add(150);
        linkedList.addLast(300);
        System.out.println(linkedList);//[200, 100, 150, 300]
1
2
3
4
5
6

  public E getFirst()及getLast()

		LinkedList linkedList = new LinkedList();
        linkedList.add(100);
        linkedList.addFirst(200);
        linkedList.add(150);
        linkedList.addLast(300);
         System.out.println(linkedList);//[200, 100, 150, 300]
        Object first = linkedList.getFirst();
        Object j = linkedList.get(2);
        Object last = linkedList.getLast();
        System.out.println(first+" "+j+" "+last);//200 150 300
1
2
3
4
5
6
7
8
9
10

  public E removeFirst()及public E removeLast()

        LinkedList linkedList = new LinkedList();
        linkedList.add(100);
        linkedList.addFirst(200);
        linkedList.add(150);
        linkedList.addLast(300);
        System.out.println(linkedList);//[200, 100, 150, 300]
        linkedList.remove(2);
        linkedList.removeFirst();
        linkedList.removeLast();
        System.out.println(linkedList);//[100]
1
2
3
4
5
6
7
8
9
10

  int indexOf (Object o) 返回此列表中首次出现的指定元素的索引，如果此列表中不包含该元素，则返回 - 1。
  int lastIndexOf (Object o)返回此列表中最后出现的指定元素的索引，如果此列表中不包含该元素，则返回 - 1。
  E peek () 获取但不移除此列表的头（第一个元素）。
  E peekFirst () 获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。
  E peekLast () 获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null。
  E pop () 从此列表所表示的堆栈处弹出一个元素。
  void push (E e) 将元素推入此列表所表示的堆栈。
  E removeFirst () 移除并返回此列表的第一个元素。
  E removeLast () 移除并返回此列表的最后一个元素。

forEach

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

forEach方法参数为一个Consumer对象，forEach方法首先会用Objects.requireNonNull(action);检查传入对象是否为null，如果是则直接抛出空指针异常，然后会对调用forEach的对象用for循环进行遍历，对遍历的每个元素调用Consumer的accept方法，accept方法需要进行重写。

//遍历输出集合
		ArrayList list = new ArrayList();
        list.add(100);
        list.add(300);
        list.add(500);
        list.add(700);
        list.forEach(new Consumer() {
            @Override
            public void accept(Object obj) {
                System.out.println(obj);
            }
        });
1
2
3
4
5
6
7
8
9
10
11
12

函数式接口

  接口中只有一个抽象方法，那么你就可以使用 Lambda 表达式来简写 来简写匿名内部类
  JDK1.8 对应函数式接口，可以使用Lambda 表达式来简写

		ArrayList list = new ArrayList();
        list.add(100);
        list.add(300);
        list.add(500);
        list.add(700);
        list.forEach(obj -> System.out.println(obj)); 
        //obj为接口中唯一抽象方法的参数，参数类型为forEach方法的参数接口Consumer的泛型，默认为Object
       //箭头后为重写该方法的内容
1
2
3
4
5
6
7
8