72.Java集合之LinkedList

LinkedList

--| Iterable
              ----| Collection
                 ------| List
                      ---------| ArrayList  底层采用数组实现，默认10。每次增长
60%,（(oldCapacity * 3)/2 + 1） 查询快，增删慢。
                 ---------| LinkedList  底层采用链表实现，增删快，查询慢。     

LinkedList:链表实现, 增删快, 查找慢

由于LinkedList:在内存中的地址不连续,需要让上一个元素记住下一个元素.所以每个元素中保存的有下一个元素的位置.虽然也有角标,但是查找的时候,需要从头往下找,显然是没有数组查找快的.但是,链表在插入新元素的时候,只需要让前一个元素记住新元素,让新元素记住下一个元素就可以了.所以插入很快.

由于链表实现, 增加时只要让前一个元素记住自己就可以, 删除时让前一个元素记住后一个元素, 后一个元素记住前一个元素. 这样的增删效率较高。

但查询时需要一个一个的遍历, 所以效率较低。

特有方法

1：方法介绍
            addFirst(E e) 
addLast(E e) 
getFirst() 
getLast() 
removeFirst() 
removeLast() 
如果集合中没有元素，获取或者删除元
素抛：NoSuchElementException
2：数据结构
                1：栈 （1.6）
                    先进后出
                    push() 
                    pop()
                2：队列（双端队列1.5）
                    先进先出
                    offer()
                    poll()
3：返回逆序的迭代器对象      
descendingIterator()   返回逆序的迭代器对象

基本方法

import java.util.Iterator;
import java.util.LinkedList;

public class Demo3 {
    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        list.add("西游记");
        list.add("三国演义");
        list.add("石头记");
        list.add("水浒传");
        list.add("全球通史");
        list.addFirst("史记");
        list.addLast("呐喊");
        // list.addFirst(null);
        // list.addLast(null);
        System.out.println(list);
        // 获取指定位置处的元素。
        String str = (String) list.get(0);
        // 返回此列表的第一个元素。
        String str2 = (String) list.getFirst();
        System.out.println(str.equals(str2));

        // 获取指定位置处的元素。
        String str3 = (String) list.get(list.size() - 1);
        // 返回此列表的最后一个元素。
        String str4 = (String) list.getLast();
        System.out.println(str3.equals(str4));

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

        int size = list.size();
        System.out.println(size);
}

迭代

import java.util.Iterator;
import java.util.LinkedList;

public class Demo3 {
    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        list.add("西游记");
        list.add("三国演义");
        list.add("石头记");
        list.add("水浒传");
        list.add("全球通史");
        Iterator it = list.iterator();
        while (it.hasNext()) {
            String next = (String) it.next();
            System.out.println(next);
        }
    }
}

逆序迭代

import java.util.Iterator;
import java.util.LinkedList;

public class Demo6 {
    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        list.add("aa");
        list.add("bb");
        list.add("cc");
        Iterator dit = list.descendingIterator();
        while (dit.hasNext()) {
            System.out.println(dit.next());
        }
    }
}

注意：可以使用该集合去模拟出队列(先进先出) 或者堆栈(后进先出) 数据结构。

堆栈(后进先出)

//堆栈(后进先出) 数据结构
public class Demo3 {
    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        // 压栈，先进后出
        list.push("西游记");
        list.push("三国演义");
        list.push("石头记");
        list.push("水浒传");
        System.out.println(list);
        // 弹栈
        String str1 = (String) list.pop();
        System.out.println(str1);
        String str2 = (String) list.pop();
        System.out.println(str2);
        String str3 = (String) list.pop();
        System.out.println(str3);
        String str4 = (String) list.pop();
        System.out.println(str4);
        System.out.println(list.size());// 0
        System.out.println(list); //[]
    }
}

队列，先进先出

import java.util.LinkedList;

public class Demo3 {
    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        // 队列，先进先出
        list.offer("西游记");
        list.offer("三国演义");
        list.offer("石头记");
        list.offer("水浒传");
        System.out.println(list);
        // 出队列
        System.out.println(list.poll());
        System.out.println(list.poll());
        System.out.println(list.poll());
        System.out.println(list.poll());

        System.out.println(list.size());

        System.out.println(list.peek()); // 获取队列的头元素，但是不删除
        System.out.println(list.peekFirst()); // 获取队列的头元素，但是不删除
        System.out.println(list.peekLast()); // 获取队列的最后一个元素但是不删除

    }
}

ArrayList 和 LinkedList的存储查找的优缺点：

1、ArrayList 是采用动态数组来存储元素的，它允许直接用下标号来直接查找对应的元素。但是，但是插入元素要涉及数组元素移动及内存的操作。总结：查找速度快，插入操作慢。

2、LinkedList 是采用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快

问题：有一批数据要存储，要求存储这批数据不能出现重复数据，ArrayList、LinkedList都没法满足需求。解决办法：使用 set集合。