LinkedList的原理和方法介紹、使用

目錄

 

LinkedList底層是雙向鏈表

變量

構造方法

public LinkedList()

public LinkedList(Collection c)

常用方法，不討論最簡單的add和remove

public void addFirst(E e)：在把元素添加在鏈表頭

public void addLast(E e)：添加在鏈表結尾

public void clear()：將數據全部置空，size=0

public Object clone() ：克隆出一個全新的鏈表，對克隆的鏈表修改，不會影響原來的鏈表

public boolean contains(Object o)：對象包含

public Iterator descendingIterator()：鏈表反序迭代

public E element()：獲取首節點的元素

public E getFirst()：獲取首節點的值

public E getLast()：獲取尾結點

public int indexOf(Object o)：元素在鏈表中第一次出現的位置

public int lastIndexOf(Object o)：元素在鏈表中最後一次出現的位置

public ListIterator listIterator(int index)：迭代的時候，能對鏈表就行修改

offer、offerLast、offerLast，將制定的元素加載到鏈表尾，鏈表尾，鏈表頭

public E peek()，peekFirst(),peekLast()：找鏈表首節點,首節點，尾節點

public E poll()；找到首節點，並刪除

public E pollFirst()；找到首節點，並刪除首節點

public E pollLast()找到尾節點，並刪除尾節點

public E pop()：獲取首節點，並刪除首節點

public void push(E e)：加入首節點

public boolean removeLastOccurrence(Object o)：移除最後出現的

Object[] toArray()：返回Object[] toArray()，無法強轉

public T[] toArray(T[] a) ：轉換數據到指定數組

---

LinkedList底層是雙向鏈表

    private static class Node<E> {
        E item;//當前元素
        Node<E> next;下一個元素
        Node<E> prev;上一個元素

        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }

變量

transient Node<E> first;	鏈表首節點
transient Node<E> last;	鏈表尾節點
transient int size = 0;	鏈表存儲數據量

構造方法

public LinkedList()

不做任何處理

public LinkedList(Collection<? extends E> c)

通過list構造

public class Test {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(3);
        list.add(4);
        list.add(2);
        List<Integer> linkedList = new LinkedList<>(list);
        System.out.println(linkedList);
    }
}

通過LinkedList構造

public class Test {
    public static void main(String[] args) {
        List<Integer> list = new LinkedList<>();
        list.add(1);
        list.add(3);
        list.add(4);
        list.add(2);
        List<Integer> linkedList = new LinkedList<>(list);
        System.out.println(linkedList);
    }
}

常用方法，不討論最簡單的add和remove

跑一遍之後，發現好多方法是重複的

public void addFirst(E e)：在把元素添加在鏈表頭

一定要使用完成類聲明LinkedList<Integer> linkedList = new LinkedList<>(list);，使用LinkedList<Integer> linkedList = new LinkedList<>(list);聲明無法使用AddFirst（）

public class Test {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1);
        list.add(3);
        list.add(4);
        list.add(2);
        list.addFirst(6);
        System.out.println(list);
    }
}

結果：

[6, 1, 3, 4, 2]

public void addLast(E e)：添加在鏈表結尾

public class Test {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1);
        list.add(3);
        list.add(4);
        list.add(2);
        list.addLast(6);
        System.out.println(list);
    }
}

結果：

[1, 3, 4, 2, 6]

public void clear()：將數據全部置空，size=0

public Object clone() ：克隆出一個全新的鏈表，對克隆的鏈表修改，不會影響原來的鏈表

public class Test {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1);
        list.add(3);
        list.add(4);
        list.add(2);
        LinkedList<Integer> clone = (LinkedList<Integer>)list.clone();
        clone.remove(1);
        System.out.println(list);
        System.out.println(clone);
    }
}

結果：

[1, 3, 4, 2]
[1, 4, 2]

public boolean contains(Object o)：對象包含

public class Test {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1);
        list.add(3);
        list.add(4);
        list.add(2);
        System.out.println(list.contains(1));
        System.out.println(list.contains(0));
    }
}

結果：

true
false

public Iterator<E> descendingIterator()：鏈表反序迭代

public class Test {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1);
        list.add(3);
        list.add(4);
        list.add(2);
        Iterator<Integer> integerIterator = list.descendingIterator();
        while(integerIterator.hasNext()){
            System.out.println(integerIterator.next());
        }
        Iterator<Integer> iterator = list.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

結果：

2
4
3
1
1
3
4
2

public E element()：獲取首節點的元素

public class Test {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1);
        list.add(3);
        list.add(4);
        list.add(2);
        System.out.println(list.element());
    }
}

結果：首節點是1，所以輸入1

1

public E getFirst()：獲取首節點的值

public class Test {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1);
        list.add(3);
        list.add(4);
        list.add(2);
        System.out.println(list.getFirst());
    }
}

結果：首節點是1，輸入1

1

public E getLast()：獲取尾結點

public class Test {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1);
        list.add(3);
        list.add(4);
        list.add(2);
        System.out.println(list.getLast());
    }
}

結果：尾結點是2，輸出2

2

public int indexOf(Object o)：元素在鏈表中第一次出現的位置

public class Test {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1);
        list.add(3);
        list.add(4);
        list.add(2);
        System.out.println(list.indexOf(3));
    }
}

結果：下標從0開始，沒有返回-1

1

public int lastIndexOf(Object o)：元素在鏈表中最後一次出現的位置

public class Test {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1);
        list.add(3);
        list.add(4);
        list.add(3);
        System.out.println(list.indexOf(5));
        System.out.println(list.lastIndexOf(3));
    }
}

結果：

-1
3

public ListIterator<E> listIterator(int index)：迭代的時候，能對鏈表就行修改

public class Test {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1);
        list.add(3);
        list.add(4);
        list.add(3);
        ListIterator<Integer> integerListIterator = list.listIterator();
        while(integerListIterator.hasNext()){
            System.out.println(integerListIterator.next());
            integerListIterator.set(8);
            integerListIterator.add(6);
        }
        System.out.println(list);
    }
}

結果：

1
3
4
3
[8, 6, 8, 6, 8, 6, 8, 6]

offer、offerLast、offerLast，將制定的元素加載到鏈表尾，鏈表尾，鏈表頭

public E peek()，peekFirst(),peekLast()：找鏈表首節點,首節點，尾節點

public class Test {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1);
        list.add(3);
        list.add(4);
        list.add(3);
        System.out.println(list.peek());
        System.out.println(list.peekFirst());
        System.out.println(list.peekLast());
        System.out.println(list);
    }
}

結果：

1
1
3
[1, 3, 4, 3]

public E poll()；找到首節點，並刪除

public class Test {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1);
        list.add(3);
        list.add(4);
        list.add(3);
        System.out.println(list.poll());
        System.out.println(list);
    }
}

結果：

1
[3, 4, 3]

public E pollFirst()；找到首節點，並刪除首節點

public E pollLast()找到尾節點，並刪除尾節點

public E pop()：獲取首節點，並刪除首節點

public class Test {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1);
        list.add(3);
        list.add(4);
        list.add(3);
        System.out.println(list.pop());
        System.out.println(list.pop());
        System.out.println(list.pop());
        System.out.println(list.pop());
        System.out.println(list);
    }
}

結果：

1
3
4
3
[]

public void push(E e)：加入首節點

public class Test {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1);
        list.add(3);
        list.add(4);
        list.add(3);
        list.push(6);
        list.push(7);
        list.push(8);
        System.out.println(list);
    }
}

結果

[8, 7, 6, 1, 3, 4, 3]

public boolean removeFirstOccurrence(Object o)：移除第一個出現的元素

public class Test {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1);
        list.add(3);
        list.add(4);
        list.add(3);
        list.removeFirstOccurrence(3);
        System.out.println(list);
    }
}

結果

[1, 4, 3]

public boolean removeLastOccurrence(Object o)：移除最後出現的

public class Test {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1);
        list.add(3);
        list.add(4);
        list.add(3);
        list.removeLastOccurrence(3);
        System.out.println(list);
    }
}

結果：

[1, 3, 4]

Object[] toArray()：返回Object[] toArray()，無法強轉

public class Test {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1);
        list.add(3);
        list.add(4);
        list.add(3);
        Object[] objects = list.toArray();
        System.out.println(objects[0]);
        System.out.println(objects[1]);
        System.out.println(objects[2]);
        System.out.println(objects[3]);
    }
}

結果

1
3
4
3

public <T> T[] toArray(T[] a) ：轉換數據到指定數組

public class Test {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1);
        list.add(3);
        list.add(4);
        list.add(3);
        Integer[] array = new Integer[list.size()];
        list.toArray(array);
        System.out.println(array[0]);
        System.out.println(array[1]);
        System.out.println(array[2]);
        System.out.println(array[3]);
    }
}

結果

1
3
4
3