java list 按 id 反向排序循环

# Java LinkedList类

Java LinkedList类使用双向链表来存储元素。它提供了链表数据结构。它继承了AbstractList类并实现了List和Deque接口。

关于Java LinkedList的重要要点如下：

• Java LinkedList类可以包含重复的元素。
• Java LinkedList类维护插入顺序。
• Java LinkedList类是非同步的。
• 在Java LinkedList类中，操作速度较快，因为不需要进行元素的移动。
• Java LinkedList类可用作列表、栈或队列。

# LinkedList类的层次结构

如上图所示，Java LinkedList类扩展了AbstractSequentialList类并实现了List和Deque接口。

# 双向链表

在双向链表中，我们可以从两端添加或删除元素。

# LinkedList类的声明

让我们看一下java.util.LinkedList类的声明。

public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>, Cloneable, Serializable

# Java LinkedList的构造函数

构造函数	描述
LinkedList()	用于构建一个空列表。
LinkedList(Collection<? extends E> c)	用于使用指定集合中的元素构建一个列表，元素的顺序是由集合的迭代器返回的顺序。

# Java LinkedList的方法

方法	描述
boolean add(E e)	将指定元素追加到列表末尾。
void add(int index, E element)	在列表中的指定位置插入指定元素。
boolean addAll(Collection<? extends E> c)	将指定集合中的所有元素追加到列表末尾，按照指定集合的迭代器返回的顺序。
boolean addAll(int index, Collection<? extends E> c)	从指定位置开始，将指定集合中的所有元素追加到列表中。
void addFirst(E e)	在列表的开头插入指定元素。
void addLast(E e)	在列表的末尾追加指定元素。
void clear()	从列表中删除所有元素。
Object clone()	返回一个ArrayList的浅拷贝。
boolean contains(Object o)	如果列表包含指定的元素，则返回true。
Iterator<E> descendingIterator()	返回一个反序遍历列表的迭代器。
E element()	获取列表的第一个元素。
E get(int index)	返回列表中指定位置的元素。
E getFirst()	返回列表中的第一个元素。
E getLast()	返回列表中的最后一个元素。
int indexOf(Object o)	返回列表中首次出现指定元素的索引，如果列表不包含该元素，则返回-1。
int lastIndexOf(Object o)	返回列表中最后一次出现指定元素的索引，如果列表不包含该元素，则返回-1。
ListIterator<E> listIterator(int index)	返回从列表中指定位置开始的元素的列表迭代器。
boolean offer(E e)	将指定元素添加为列表的最后一个元素。
boolean offerFirst(E e)	将指定元素插入到列表的开头。
boolean offerLast(E e)	将指定元素插入到列表的末尾。
E peek()	获取列表的第一个元素。
E peekFirst()	获取列表的第一个元素，如果列表为空，则返回null。
E peekLast()	获取列表的最后一个元素，如果列表为空，则返回null。
E poll()	获取并删除列表的第一个元素。
E pollFirst()	获取并删除列表的第一个元素，如果列表为空，则返回null。
E pollLast()	获取并删除列表的最后一个元素，如果列表为空，则返回null。
E pop()	从列表表示的堆栈中弹出一个元素。
void push(E e)	将一个元素推入到列表表示的堆栈中。
E remove()	获取并删除列表的第一个元素。
E remove(int index)	删除列表中指定位置的元素。
boolean remove(Object o)	删除列表中首次出现的指定元素。
E removeFirst()	删除并返回列表中的第一个元素。
boolean removeFirstOccurrence(Object o)	删除列表中首次出现的指定元素（从头到尾遍历列表时）。
E removeLast()	删除并返回列表中的最后一个元素。
boolean removeLastOccurrence(Object o)	删除列表中最后一次出现的指定元素（从头到尾遍历列表时）。
E set(int index, E element)	使用指定元素替换列表中指定位置的元素。
Object[] toArray()	返回包含列表中所有元素的数组，按照适当的顺序（从第一个元素到最后一个元素）排序。
<T> T[] toArray(T[] a)	返回包含适当顺序（从第一个元素到最后一个元素）的列表中所有元素的数组；返回数组的运行时类型是指定数组的运行时类型。
int size()	返回列表中的元素数。

# Java LinkedList示例

1. import java.util.*;
2. public class LinkedList1 {
3.     public static void main(String args[]) {
4.
5.         LinkedList<String> al = new LinkedList<String>();
6.         al.add("Ravi");
7.         al.add("Vijay");
8.         al.add("Ravi");
9.         al.add("Ajay");
10.
11.        Iterator<String> itr = al.iterator();
12.        while (itr.hasNext()) {
13.            System.out.println(itr.next());
14.        }
15.    }
16.}

输出:

Ravi
Vijay
Ravi
Ajay

# Java LinkedList示例-添加元素

这里我们看到了不同的添加元素的方法。

1. import java.util.*;
2. public class LinkedList2 {
3.     public static void main(String args[]) {
4.         LinkedList<String> ll = new LinkedList<String>();
5.         System.out.println("Initial list of elements: " + ll);
6.         ll.add("Ravi");
7.         ll.add("Vijay");
8.         ll.add("Ajay");
9.         System.out.println("After invoking add(E e) method: " + ll);
10.        // 在特定位置添加元素
11.        ll.add(1, "Gaurav");
12.        System.out.println("After invoking add(int index, E element) method: " + ll);
13.        LinkedList<String> ll2 = new LinkedList<String>();
14.        ll2.add("Sonoo");
15.        ll2.add("Hanumat");
16.        // 将第二个列表的元素添加到第一个列表中
17.        ll.addAll(ll2);
18.        System.out.println("After invoking addAll(Collection<? extends E> c) method: " + ll);
19.        LinkedList<String> ll3 = new LinkedList<String>();
20.        ll3.add("John");
21.        ll3.add("Rahul");
22.        // 将第二个列表的元素添加到第一个列表中的特定位置
23.        ll.addAll(1, ll3);
24.        System.out.println("After invoking addAll(int index, Collection<? extends E> c) method: " + ll);
25.        // 在第一个位置添加一个元素
26.        ll.addFirst("Lokesh");
27.        System.out.println("After invoking addFirst(E e) method: " + ll);
28.        // 在最后一个位置添加一个元素
29.        ll.addLast("Harsh");
30.        System.out.println("After invoking addLast(E e) method: " + ll);
31.    }
32.}

输出:

Initial list of elements: []
After invoking add(E e) method: [Ravi, Vijay, Ajay]
After invoking add(int index, E element) method: [Ravi, Gaurav, Vijay, Ajay]
After invoking addAll(Collection<? extends E> c) method: 
[Ravi, Gaurav, Vijay, Ajay, Sonoo, Hanumat]
After invoking addAll(int index, Collection<? extends E> c) method: 
[Ravi, John, Rahul, Gaurav, Vijay, Ajay, Sonoo, Hanumat]
After invoking addFirst(E e) method: 
[Lokesh, Ravi, John, Rahul, Gaurav, Vijay, Ajay, Sonoo, Hanumat]
After invoking addLast(E e) method: 
[Lokesh, Ravi, John, Rahul, Gaurav, Vijay, Ajay, Sonoo, Hanumat, Harsh]

# Java LinkedList示例-删除元素

这里我们看到了不同的删除元素的方法。

1. import java.util.*;
2. public class LinkedList3 {
3.     public static void main(String[] args) {
4.         LinkedList<String> ll = new LinkedList<String>();
5.         ll.add("Ravi");
6.         ll.add("Vijay");
7.         ll.add("Ajay");
8.         ll.add("Anuj");
9.         ll.add("Gaurav");
10.        ll.add("Harsh");
11.        ll.add("Virat");
12.        ll.add("Gaurav");
13.        ll.add("Harsh");
14.        ll.add("Amit");
15.        System.out.println("Initial list of elements: " + ll);
16.        // 从链表中删除特定元素
17.        ll.remove("Vijay");
18.        System.out.println("After invoking remove(object) method: " + ll);
19.        // 根据特定位置删除元素
20.        ll.remove(0);
21.        System.out.println("After invoking remove(index) method: " + ll);
22.        LinkedList<String> ll2 = new LinkedList<String>();
23.        ll2.add("Ravi");
24.        ll2.add("Hanumat");
25.        // 向链表中添加新元素
26.        ll.addAll(ll2);
27.        System.out.println("Updated list: " + ll);
28.        // 从链表中删除所有新元素
29.        ll.removeAll(ll2);
30.        System.out.println("After invoking removeAll() method: " + ll);
31.        // 从链表中删除第一个元素
32.        ll.removeFirst();
33.        System.out.println("After invoking removeFirst() method: " + ll);
34.        // 从链表中删除最后一个元素
35.        ll.removeLast();
36.        System.out.println("After invoking removeLast() method: " + ll);
37.        // 从链表中删除第一个出现的元素
38.        ll.removeFirstOccurrence("Gaurav");
39.        System.out.println("After invoking removeFirstOccurrence() method: " + ll);
40.        // 从链表中删除最后一个出现的元素
41.        ll.removeLastOccurrence("Harsh");
42.        System.out.println("After invoking removeLastOccurrence() method: " + ll);
43.
44.        // 从链表中删除所有元素
45.        ll.clear();
46.        System.out.println("After invoking clear() method: " + ll);
47.    }
48.}

输出:

Initial list of elements: [Ravi, Vijay, Ajay, Anuj, Gaurav, Harsh, Virat, Gaurav, Harsh, Amit]
After invoking remove(object) method: [Ravi, Ajay, Anuj, Gaurav, Harsh, Virat, Gaurav, Harsh, Amit]
After invoking remove(index) method: [Ajay, Anuj, Gaurav, Harsh, Virat, Gaurav, Harsh, Amit]
Updated list: [Ajay, Anuj, Gaurav, Harsh, Virat, Gaurav, Harsh, Amit, Ravi, Hanumat]
After invoking removeAll() method: [Ajay, Anuj, Gaurav, Harsh, Virat, Gaurav, Harsh, Amit]
After invoking removeFirst() method: [Gaurav, Harsh, Virat, Gaurav, Harsh, Amit]
After invoking removeLast() method: [Gaurav, Harsh, Virat, Gaurav, Harsh]
After invoking removeFirstOccurrence() method: [Harsh, Virat, Gaurav, Harsh]
After invoking removeLastOccurrence() method: [Harsh, Virat, Gaurav]
After invoking clear() method: []

# Java LinkedList示例-反转元素列表

1. import java.util.*;
2. public class LinkedList4 {
3.     public static void main(String args[]) {
4.         LinkedList<String> ll = new LinkedList<String>();
5.         ll.add("Ravi");
6.         ll.add("Vijay");
7.         ll.add("Ajay");
8.         // 以相反的顺序遍历元素列表
9.         Iterator i = ll.descendingIterator();
10.        while (i.hasNext()) {
11.            System.out.println(i.next());
12.        }
13.    }
14.}

输出:

Ajay
Vijay
Ravi

# Java LinkedList示例-书籍

1. import java.util.*;
2. class Book {
3.     int id;
4.     String name, author, publisher;
5.     int quantity;
6.     public Book(int id, String name, String author, String publisher, int quantity) {
7.         this.id = id;
8.         this.name = name;
9.         this.author = author;
10.        this.publisher = publisher;
11.        this.quantity = quantity;
12.    }
13.}
14. public class LinkedListExample {
15.    public static void main(String[] args) {
16.        // 创建书籍列表
17.        List<Book> list = new LinkedList<Book>();
18.        // 创建书籍
19.        Book b1 = new Book(101, "Let us C", "Yashwant Kanetkar", "BPB", 8);
20.        Book b2 = new Book(102, "Data Communications & Networking", "Forouzan", "Mc Graw Hill", 4);
21.        Book b3 = new Book(103, "Operating System", "Galvin", "Wiley", 6);
22.        // 将书籍添加到列表中
23.        list.add(b1);
24.        list.add(b2);
25.        list.add(b3);
26.        // 遍历列表
27.        for (Book b : list) {
28.            System.out.println(b.id + " " + b.name + " " + b.author + " " + b.publisher + " " + b.quantity);
29.        }
30.    }
31.}

输出:

101 Let us C Yashwant Kanetkar BPB 8
102 Data Communications & Networking Forouzan Mc Graw Hill 4
103 Operating System Galvin Wiley 6