LinkedList

1. 获取第一个和最后一个元素

        LinkedList<String> linkedList = new LinkedList<String>();
        linkedList.add("1");
        linkedList.add("2");
        linkedList.add("3");
        linkedList.add("4");

        /**
         *  1. 获取第一个和最后一个元素
         */
        System.out.println("链表第一个元素是：" + linkedList.getFirst());
        System.out.println("链表最后一个元素是：" + linkedList.getLast());

2. 遍历链表所有元素

        /**
         *  2. 遍历链表所有元素
         */
        for (String str: linkedList) {
            System.out.print(str + " ");
        }
        System.out.println();

3. 链表生成子表

        /**
         *  3. 链表生成子表
         */
        List<String> subList = linkedList.subList(1, 4);
        System.out.println(subList);
        // 移除索引为2的元素
        subList.remove(2);
        System.out.println(subList);
        System.out.println(linkedList);

4. 添加元素，添加单个元素

        /**
         *  4. 添加元素，添加单个元素
         */
        LinkedList<String> list = new LinkedList<String>();
        // 不指定索引，元素被添加到链表最后
        list.add("A");
        list.add("B");
        list.add("C");
        list.add("D");
        // 指定位置，如addFirst()、addLast()
        list.addFirst("X");
        list.addLast("Z");
        System.out.println(list);
        // Output: [X, A, B, C, D, Z]

5. 删除元素

        /**
         *  5. 删除元素
         */
        list.removeFirst();
        list.removeLast();
        System.out.println(list);
        // Output: [A, B, C, D]

6. LinkedList 转换成 ArrayList

        /**
         *  6. LinkedList 转换成ArrayList
         */
        ArrayList<String> arrayList = new ArrayList<String>(linkedList);
        for (String s:arrayList) {
            System.out.println("s = " + s);
        }

7. 删除所有元素

        /**
         *  7. 删除所有元素
         */
        arrayList.clear();

8. 删除列表首位元素

        /**
         *  8. 删除列表首位元素
         */
        System.out.println("The original list: " + list);
        Object object = list.removeFirst();
        System.out.println(object + " has been removed");
        System.out.println(list);
        object = list.removeLast();
        System.out.println(object + " has been removed");
        System.out.println(list);

9. 根据范围删除列表元素

        /**
         *  9. 根据范围删除列表元素
         */
        LinkedList<String> linkedList1 = new LinkedList<String>();
        for (int i = 1; i <= 5; i++) {
            // String.valueOf(), 将基本数据类型转化成String
            linkedList1.add(String.valueOf(i));
        }
        System.out.println(linkedList1);
        // 从索引 [2, 5) 范围删除元素
        linkedList1.subList(2,5).clear();
        System.out.println(linkedList1);

10. 删除链表特定元素

        /**
         *  10. 删除链表特定元素
         */
        LinkedList<String> lList = new LinkedList<String>();
        for (int i = 1; i <= 5; i++) {
            lList.add(String.valueOf(i));
        }
        System.out.println(lList);
        // Output: [1, 2, 3, 4, 5]
        // 删除列表特定元素，此处为元素值=2的元素
        System.out.println(lList.remove("2"));
        System.out.println(lList);
        // Output: [1, 3, 4, 5]
        // 删除索引为2的元素
        Object obj = lList.remove(2);
        System.out.println(obj + " has been removed");
        System.out.println(lList);
        // Output: [1, 3, 5]

11. 将LinkedList转换成数组，数组长度为0

        /**
         *  11. 将LinkedList转换成数组，数组长度为0
         */
        List<String> theList = new LinkedList<String>();
        theList.add("A");
        theList.add("B");
        theList.add("C");
        theList.add("D");
        String[] myList = theList.toArray(new String[0]);
        for (int i = 0; i < myList.length; i++) {
            System.out.println(myList[i]);
        }

12. LinkedList转换为数组，数组长度为链表长度

        /**
         *  12. LinkedList转换为数组，数组长度为链表长度
         */
        List<String> theList1 = new LinkedList<String>();
        theList1.add("A");
        theList1.add("B");
        theList1.add("C");
        theList1.add("D");
        String[] myList1 = theList1.toArray(new String[theList1.size()]);
        for (int i = 0; i < myList1.length; i++) {
            System.out.println(myList1[i]);
        }

13. LinkedList 转换成 ArrayList

        /**
         *  13. 将LinkedList转换成ArrayList
         */
        LinkedList<String> myQueue = new LinkedList<String>();
        myQueue.add("A");
        myQueue.add("B");
        myQueue.add("C");
        myQueue.add("D");
        // LinkedList translates ArrayList
        List<String> myList2 = new ArrayList<String>(myQueue);
        for (Object theFruit:
             myList2) {
            System.out.println(theFruit);
        }

14. 根据链表元素生成对象数组

        /**
         *  14. 根据链表元素生成对象数组
         */
        Object[] objArray = myQueue.toArray();
        for (Object objection:
             objArray) {
            System.out.println(objection);
        }

15. 查找元素位置 && 替换元素 && 确认链表存在特定元素

/**
 *  查找元素位置 && 替换元素 && 确认链表存在特定元素
 */
public class TestLinkedListSearchElement {
    public static void main(String[] args) {
        LinkedList<String> linkedList = new LinkedList<String>();
        linkedList.add("1");
        linkedList.add("2");
        linkedList.add("3");
        linkedList.add("4");
        linkedList.add("5");
        linkedList.add("6");
        System.out.println(linkedList.indexOf("2"));
        System.out.println(linkedList.lastIndexOf("2"));
        // 使用set方法替换元素，方法第一个参数是索引，后一个是替换值
        linkedList.set(3, "Replaced");
        System.out.println(linkedList);
        // Output: [1, 2, 3, Replaced, 5, 6]

        if (linkedList.contains("4")) {
            System.out.println("LinkedList contains 4");
        }
        else {
            System.out.println("LinkedList does not contain 4");
        }
    }
}