Java类LinkedList常用API详解

痛定思痛。 2023-03-01 12:20 1阅读 0赞

**LinkedList - 测试类**

package LinkedList_UtilityClass;
    
    import java.util.*;
    
    /**
     * LinkedList测试类
     */
    public class LinkedListTest {
    
        public static void main(String[] args) {
    
            /**
             * 集合存储的是引用数据类型，集合的主要类型有3种，分别是List、Set、Map
             *
             * LinkedList底层数据结构是链表，其特点是增删快，查询慢，线程不安全但效率高
             *
             * LinkedList中功能相似的方法
             * 将指定元素插入此列表的开头：addFirst(E e); || offerFirst(E e);
             * 将指定元素添加到此列表的结尾：addLast(E e); || offerLast(E e);
             *
             * 将指定元素添加到此列表的结尾：add(E e); || offer(E e);
             * 获取并移除此列表的头：poll(); || remove();
             *
             * 移除此列表的第一个元素：removeFirst(); || pollFirst();
             * 移除此列表的最后一个元素：removeLast(); || pollLast();
             * Tips：此处带remove的方法表示移除并返回，带poll的方法表示获取并移除
             */
    
            // 在列表末尾添加元素
            LinkedList<String> linkList = new LinkedList<String>(Arrays.asList(new String[]{"A", "B", "C", "D"}));
            linkList.add("End");
            System.out.println("在原列表的末尾添加元素End：" + linkList.toString());
    
            // 在列表的指定位置处添加(插入)元素
            linkList.add(4, "Insert");
            System.out.println("在原列表的 4 位置后添加元素Insert(位置从1开始)：" + linkList.toString());
    
            System.out.println("--------------------------------------------------------------------------------");
    
            // 将另一个集合中的所有元素添加至当前列表中
            LinkedList<String> tempList = new LinkedList<String>(Arrays.asList(new String[]{"10", "20", "30"}));
            linkList.addAll(tempList);
            System.out.println("(A - 末尾)将另一个集合中的元素添加至原有的集合中：" + linkList.toString());
    
            // 将另一个集合中的所有元素添加至当前列表的指定位置
            linkList.addAll(0, tempList);
            System.out.println("(B - 开头)将另一个集合中的元素添加至原有的集合中：" + linkList.toString());
    
            System.out.println("--------------------------------------------------------------------------------");
    
            // 将指定元素插入到此列表的开头
            tempList.addFirst("First");
            System.out.println("在临时列表的所有元素前添加一个元素First：" + tempList.toString());
    
            // 将指定元素插入到此列表的末尾
            tempList.addLast("Last");
            System.out.println("在临时列表的所有元素后添加一个元素Last：" + tempList.toString());
    
            System.out.println("--------------------------------------------------------------------------------");
    
            // 移除列表中的所有元素
            linkList.clear();
            System.out.println("移除列表中的所有元素：" + linkList.toString());
    
            System.out.println("--------------------------------------------------------------------------------");
    
            // 返回当前列表实例的浅表副本(浅克隆)
            Object clone = tempList.clone();
            System.out.println("临时列表元素浅克隆：" + clone.toString());
            System.out.println("Tips：列表元素深克隆请参考ArrayList测试类！");
    
            System.out.println("--------------------------------------------------------------------------------");
    
            // 判断当前列表中是否包含某个元素
            boolean conFlag = tempList.contains("Constains");
            if (conFlag) {
                System.out.println("提示：列表中存在元素Contains！");
            } else {
                System.out.println("提示：列表中不存在元素Contains！");
            }
    
            System.out.println("--------------------------------------------------------------------------------");
    
            // 列表元素反序迭代输出(类似于数组元素倒序输出)
            LinkedList<Integer> numList = new LinkedList<Integer>(Arrays.asList(new Integer[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}));
            System.out.println("原列表中的元素顺序：");
            for (Integer items : numList) {
                System.out.print(items + "    ");
            }
            System.out.println("\n列表元素反序迭代输出：");
            Iterator<Integer> iterator = numList.descendingIterator();
            for (Iterator<Integer> it = iterator; it.hasNext(); ) {
                System.out.print(it.next() + "    ");
            }
            // 其它迭代方式
    //        while(iterator.hasNext()) {
    //            System.out.print(iterator.next() + "    ");
    //        }
    
            System.out.println("\n--------------------------------------------------------------------------------");
    
            // 返回列表的第一个元素
            System.out.println("当前列表元素：" + numList.toString());
            Integer target = numList.element();
            System.out.println("列表的第一个元素：" + target);
    
            System.out.println("--------------------------------------------------------------------------------");
    
            // 列表元素获取
            System.out.println("列表的第5个元素为(下标从0开始)：" + numList.get(5));
            System.out.println("列表的首元素为：" + numList.getFirst());
            System.out.println("列表的尾元素为：" + numList.getLast());
    
            System.out.println("--------------------------------------------------------------------------------");
    
            // 查找某元素在列表中首次出现的下标，找到一个即停，未找到则返回-1
            System.out.println("当前列表中的元素：" + tempList.toString());
            int index_20 = tempList.indexOf("20");
            System.out.println("元素20在列表中的下标为(indexOf)：" + index_20);
    
            // 查找某元素在列表中最后一次出现的下标，找到一个即停，未找到则返回-1
            int index_0 = tempList.lastIndexOf("0");
            System.out.println("元素0在列表中的下标为(lastIndexOf)：" + index_0);
    
            System.out.println("--------------------------------------------------------------------------------");
    
            // 判断此列表是否为空
            System.out.println("当前列表是否为空(true - 空；false - 非空)：" + tempList.isEmpty());;
    
            System.out.println("--------------------------------------------------------------------------------");
    
            // 从指定位置处开始迭代列表中的元素
            System.out.println("当前列表中的元素：" + numList.toString());
            ListIterator<Integer> listIter = numList.listIterator(5);
            System.out.print("从位置 5 处开始迭代列表元素：");
            for (ListIterator<Integer> iter = listIter; listIter.hasNext(); ) {
                System.out.print(iter.next() + "    ");
            }
    
            System.out.println("\n--------------------------------------------------------------------------------");
    
            System.out.println("当前列表中的元素：" + numList.toString());
            // 将指定元素添加到列表的末尾
            numList.offer(0);
            System.out.println("在列表末尾添加一个元素 0：" + numList.toString());
    
            // 在列表的开头插入指定元素
            numList.offerFirst(-1);
            System.out.println("在列表开头添加一个元素 -1：" + numList.toString());
    
            // 在列表末尾插入指定元素
            numList.offerLast(100);
            System.out.println("在列表末尾添加一个元素 100：" + numList.toString());
    
            System.out.println("--------------------------------------------------------------------------------");
    
            LinkedList<String> testList = new LinkedList<String>(Arrays.asList(new String[]{"A", "B", "C", "D", "E"}));
            // 获取但不移除此列表的头
            System.out.println("获取但不移除列表的头：" + testList.peek());
    
            // 获取但不移除此列表的第一个元素，若列表为空则返回null
            System.out.println("获取但不移除此列表的第一个元素：" + testList.peekFirst());
    
            // 获取但不移除此列表的最后一个元素，若列表为空则返回null
            System.out.println("获取但不移除此列表的最后一个元素：" + testList.peekLast());
    
            System.out.println("--------------------------------------------------------------------------------");
    
            // 获取并移除此列表的头
            System.out.println("获取并移除此列表的头：" + testList.poll());
    
            // 获取并移除此列表的第一个元素，若列表为空则返回null
            System.out.println("获取并移除此列表的第一个元素：" + testList.pollFirst());
    
            // 获取并移除此列表的最后一个元素，若列表为空则返回null
            System.out.println("获取并移除此列表的最后一个元素：" + testList.pollLast());
    
            System.out.println("--------------------------------------------------------------------------------");
    
            // 从此列表所表示的堆栈处弹出一个元素
            System.out.println("测试列表中的剩余元素：" + testList.toString());
            System.out.println("从此列表所表示的堆栈处弹出一个元素：" + testList.pop());
    
            // 将元素推入此列表所表示的堆栈
            System.out.println("测试列表中的剩余元素：" + testList.toString());
            testList.push("TestPush");
            System.out.println("将元素 TestPush 推入此列表所表示的堆栈：" + testList.toString());
    
            System.out.println("--------------------------------------------------------------------------------");
    
            LinkedList<String> removeTest = new LinkedList<String>(Arrays.asList(new String[]{"A", "B", "C", "D", "E"}));
            System.out.println("当前列表元素：" + removeTest.toString());
            // 获取并移除此列表的头
            System.out.println("获取并移除此列表的头：" + removeTest.remove());
            // 移除此列表中指定位置处的元素
            System.out.println("移除此列表中指定位置处的元素(第0个)：" + removeTest.remove(0));
            // 若存在某元素，则从此列表中移除首次出现的指定元素
            System.out.println("若列表中存在某目标元素则移除对应的目标元素 - A(存在 - true；不存在 - false)：" + removeTest.remove("X"));
            // 移除并返回此列表的第一个元素
            System.out.println("移除并返回此列表的第一个元素：" + removeTest.removeFirst());
            // 移除并返回此列表的最后一个元素
            System.out.println("移除并返回此列表的最后一个元素：" + removeTest.removeLast());
            // 从此列表中移除第一次出现的指定元素
            System.out.println("移除并返回此列表的最后一个元素 - A：" + removeTest.removeFirstOccurrence("Y"));
            // 从此列表中移除最后一次出现的指定元素
            System.out.println("移除并返回此列表的最后一个元素 - A：" + removeTest.removeLastOccurrence("Y"));
    
            System.out.println("--------------------------------------------------------------------------------");
    
            // 将此列表中某位置的元素替换为指定的元素
            LinkedList<String> setTest = new LinkedList<String>(Arrays.asList(new String[]{"A", "B", "C", "D", "E"}));
            System.out.println("原列表中的元素：" + setTest.toString());
            setTest.set(2, "S");
            System.out.println("用S替换C后原列表中的元素(下标从0开始)：" + setTest.toString());
    
            System.out.println("--------------------------------------------------------------------------------");
            
            // 列表元素区间截取(含头不含尾)
            System.out.println("原列表中的元素：" + setTest.toString());
            List<String> subList = setTest.subList(1, 4);
            System.out.print("从集合的 1 下标处截取到 4 下标处的结果为：");
            for (String items : subList) {
                System.out.print(items + "    ");
            }
    
            System.out.println("\n--------------------------------------------------------------------------------");
            
            // 获取当前列表的元素数(长度)
            System.out.println("当前列表中的元素数：" + setTest.size());
    
            System.out.println("--------------------------------------------------------------------------------");
    
            // 将列表中的元素存入数组
            Object[] objects = setTest.toArray();
            System.out.print("toArray(); - 将列表中的元素存入数组：");
            for (Object items : objects) {
                System.out.print(items + "    ");
            }
    
            Object obj[] = new Object[setTest.size()];
            setTest.toArray(obj);
            System.out.print("\ntoArray(T[] a); - 将列表中的元素存入数组：");
            for (Object items : obj) {
                System.out.print(items + "    ");
            }
    
        }
    
    }

**运行示范**

在原列表的末尾添加元素End：[A, B, C, D, End]
    在原列表的 4 位置后添加元素Insert(位置从1开始)：[A, B, C, D, Insert, End]
    --------------------------------------------------------------------------------
    (A - 末尾)将另一个集合中的元素添加至原有的集合中：[A, B, C, D, Insert, End, 10, 20, 30]
    (B - 开头)将另一个集合中的元素添加至原有的集合中：[10, 20, 30, A, B, C, D, Insert, End, 10, 20, 30]
    --------------------------------------------------------------------------------
    在临时列表的所有元素前添加一个元素First：[First, 10, 20, 30]
    在临时列表的所有元素后添加一个元素Last：[First, 10, 20, 30, Last]
    --------------------------------------------------------------------------------
    移除列表中的所有元素：[]
    --------------------------------------------------------------------------------
    临时列表元素浅克隆：[First, 10, 20, 30, Last]
    Tips：列表元素深克隆请参考ArrayList测试类！
    --------------------------------------------------------------------------------
    提示：列表中不存在元素Contains！
    --------------------------------------------------------------------------------
    原列表中的元素顺序：
    1    2    3    4    5    6    7    8    9    10    
    列表元素反序迭代输出：
    10    9    8    7    6    5    4    3    2    1    
    --------------------------------------------------------------------------------
    当前列表元素：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    列表的第一个元素：1
    --------------------------------------------------------------------------------
    列表的第5个元素为(下标从0开始)：6
    列表的首元素为：1
    列表的尾元素为：10
    --------------------------------------------------------------------------------
    当前列表中的元素：[First, 10, 20, 30, Last]
    元素20在列表中的下标为(indexOf)：2
    元素0在列表中的下标为(lastIndexOf)：-1
    --------------------------------------------------------------------------------
    当前列表是否为空(true - 空；false - 非空)：false
    --------------------------------------------------------------------------------
    当前列表中的元素：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    从位置 5 处开始迭代列表元素：6    7    8    9    10    
    --------------------------------------------------------------------------------
    当前列表中的元素：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    在列表末尾添加一个元素 0：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0]
    在列表开头添加一个元素 -1：[-1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0]
    在列表末尾添加一个元素 100：[-1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0, 100]
    --------------------------------------------------------------------------------
    获取但不移除列表的头：A
    获取但不移除此列表的第一个元素：A
    获取但不移除此列表的最后一个元素：E
    --------------------------------------------------------------------------------
    获取并移除此列表的头：A
    获取并移除此列表的第一个元素：B
    获取并移除此列表的最后一个元素：E
    --------------------------------------------------------------------------------
    测试列表中的剩余元素：[C, D]
    从此列表所表示的堆栈处弹出一个元素：C
    测试列表中的剩余元素：[D]
    将元素 TestPush 推入此列表所表示的堆栈：[TestPush, D]
    --------------------------------------------------------------------------------
    当前列表元素：[A, B, C, D, E]
    获取并移除此列表的头：A
    移除此列表中指定位置处的元素(第0个)：B
    若列表中存在某目标元素则移除对应的目标元素 - A(存在 - true；不存在 - false)：false
    移除并返回此列表的第一个元素：C
    移除并返回此列表的最后一个元素：E
    移除并返回此列表的最后一个元素 - A：false
    移除并返回此列表的最后一个元素 - A：false
    --------------------------------------------------------------------------------
    原列表中的元素：[A, B, C, D, E]
    用S替换C后原列表中的元素(下标从0开始)：[A, B, S, D, E]
    --------------------------------------------------------------------------------
    原列表中的元素：[A, B, S, D, E]
    从集合的 1 下标处截取到 4 下标处的结果为：B    S    D    
    --------------------------------------------------------------------------------
    当前列表中的元素数：5
    --------------------------------------------------------------------------------
    toArray(); - 将列表中的元素存入数组：A    B    S    D    E    
    toArray(T[] a); - 将列表中的元素存入数组：A    B    S    D    E

隔行如隔山，所谓的编程思维，指的就是专业经验以及行业感觉。

学习就像是一面镜子，你若欺骗学习，学习必将欺骗你。