LinkedList的常用方法

     	LinkedList<Integer> linkedList = new LinkedList<>();
        //将元素插入到末尾
        linkedList.add(1);
        linkedList.add(2);
        linkedList.add(3);
        System.out.println("linkedList中现有元素为:   " + linkedList);    //linkedList中现有元素为:   [1, 2, 3]
        //指定位置插入指定元素 位置应满足：index >= 0 && index <= size 否则会索引越界
        int addIndex = 2;
        int addValue = 7;
        linkedList.add(addIndex, addValue);
        System.out.printf("在指定位置[%d]插入元素[%d]后，链表中元素为： %s", addIndex, addValue, linkedList);  //在指定位置[2]插入元素[7]后，链表中元素为： [1, 2, 7, 3]
        System.out.println();
        //将另一个集合中的数据插入
        linkedList.addAll(Arrays.asList(10, 11));
        System.out.println("插入集合后，链表中元素为：" + linkedList);   //插入集合后，链表中元素为：[1, 2, 7, 3, 10, 11]
        //在头部插入元素
        linkedList.addFirst(20);
        System.out.println("linkedList中现有元素为:   " + linkedList);    //linkedList中现有元素为:   [20, 1, 2, 7, 3, 10, 11]

        //在尾部插入元素
        linkedList.addLast(6);
        System.out.println("linkedList中现有元素为:   " + linkedList);    //linkedList中现有元素为:   [20, 1, 2, 7, 3, 10, 11, 6]

        if (linkedList.contains(20)) {
            System.out.println("链表中存在值20");     //链表中存在值20
        } else {
            System.out.println("链表中不存在值20");
        }

        //检索但不删除链表的头部
        System.out.println("链表的头部位置的数为： " + linkedList.element()); //链表的头部位置的数为： 20

        //获取某个索引上的数
        System.out.println("链表上索引位置为6的数为： " + linkedList.get(6)); //链表上索引位置为6的数为： 11
        //链表上头部元素
        System.out.println("链表上第一个元素为： " + linkedList.getFirst());  //链表上第一个元素为： 20
        //返回此列表中的最后一个元素
        System.out.println("链表上最后一个元素为： " + linkedList.getLast());  //链表上最后一个元素为： 6

        //返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。
        System.out.println("元素6在链表上第一次出现的位置为： " + linkedList.indexOf(6));   //元素6在链表上第一次出现的位置为： 7
        System.out.println("元素60在链表上第一次出现的位置为： " + linkedList.indexOf(60));  //元素60在链表上第一次出现的位置为： -1
        //返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。
        System.out.println("元素20在链表上最后一次出现的位置为： " + linkedList.lastIndexOf(20));  //元素20在链表上最后一次出现的位置为： 0


        //将指定的元素添加为此列表的尾部（最后一个元素）
        linkedList.offer(21);
        System.out.println("linkedList中现有元素为:   " + linkedList);    //linkedList中现有元素为:   [20, 1, 2, 7, 3, 10, 11, 6, 21]

        //在此列表的前面插入指定的元素
        linkedList.offerFirst(0);
        System.out.println("linkedList中现有元素为:   " + linkedList);    //linkedList中现有元素为:   [0, 20, 1, 2, 7, 3, 10, 11, 6, 21]

        //在该列表的末尾插入指定的元素
        linkedList.offerLast(100);
        System.out.println("linkedList中现有元素为:   " + linkedList);    //linkedList中现有元素为:   [0, 20, 1, 2, 7, 3, 10, 11, 6, 21, 100]
        //检索但不删除此列表的头（第一个元素）
        Integer peekValue = linkedList.peek();
        System.out.println("peek结果--链表的第一个元素为：" + peekValue);   //peek结果--链表的第一个元素为：0
        //检索但不删除此列表的第一个元素，如果此列表为空，则返回 null 。
        Integer peekFirstValue = linkedList.peekFirst();
        System.out.println("peekFirst结果--链表的第一个元素为: " + peekFirstValue);    //peekFirst结果--链表的第一个元素为: 0
        //检索但不删除此列表的最后一个元素，如果此列表为空，则返回 null 。
        Integer peekLastValue = linkedList.peekLast();
        System.out.println("peekLast结果--链表的最后一个元素为: " + peekLastValue);     //peekLast结果--链表的最后一个元素为: 100
   //检索并删除此列表的头（第一个元素）
        Integer pollValue = linkedList.poll();
        System.out.printf("链表删除头部元素[%d]后，剩余的元素为[%s]", pollValue, linkedList);   //链表删除头部元素[0]后，剩余的元素为[[20, 1, 2, 7, 3, 10, 11, 6, 21, 100]]
        System.out.println();
        //检索并删除此列表的第一个元素，如果此列表为空，则返回 null
        Integer pollFirstValue = linkedList.pollFirst();
        System.out.printf("链表删除头部元素[%d]后，剩余的元素为[%s]", pollFirstValue, linkedList);  //链表删除头部元素[20]后，剩余的元素为[[1, 2, 7, 3, 10, 11, 6, 21, 100]]
        System.out.println();
        //检索并删除此列表的最后一个元素，如果此列表为空，则返回 null
        Integer pollLastValue = linkedList.pollLast();
        System.out.printf("链表删除尾部元素[%d]后，剩余的元素为[%s]", pollLastValue, linkedList);   //链表删除尾部元素[100]后，剩余的元素为[[1, 2, 7, 3, 10, 11, 6, 21]]
        System.out.println();
        //从此列表表示的堆栈中弹出一个元素。
        Integer popValue = linkedList.pop();
        System.out.printf("弹出元素[%d]后，剩余的元素为[%s]", popValue, linkedList);    //弹出元素[1]后，剩余的元素为[[2, 7, 3, 10, 11, 6, 21]]
        System.out.println();

        int pushValue = 101;
        //将元素推送到由此列表表示的堆栈上。
        linkedList.push(pushValue);
        System.out.printf("给栈中压入元素[%d]后，剩余的元素为[%s]", pushValue, linkedList);    //给栈中压入元素[101]后，剩余的元素为[[101, 2, 7, 3, 10, 11, 6, 21]]
        System.out.println();

        //检索并删除此列表的头（第一个元素）
        Integer removeValue = linkedList.remove();
        System.out.printf("删除链表中元素[%d]后，剩余的元素为[%s]", removeValue, linkedList);  //删除链表中元素[101]后，剩余的元素为[[2, 7, 3, 10, 11, 6, 21]]
        System.out.println();
        Integer removeIndexValue = linkedList.remove(2);
        System.out.printf("移除索引2处元素[%d]后，剩余的元素为[%s]", removeIndexValue , linkedList); //移除索引2处元素[101]后，剩余的元素为[[2, 7, 10, 11, 6, 21]]
        System.out.println();
        //从此列表中删除并返回第一个元素。
        Integer removeFirstValue = linkedList.removeFirst();
        System.out.printf("移除头部元素[%d]后，剩余的元素为：%s", removeFirstValue, linkedList);	移除头部元素[2]后，剩余的元素为：[7, 10, 11, 6, 21]
        System.out.println();
        //从此列表中删除并返回第一个元素。
        Integer removeLastValue = linkedList.removeLast();
        System.out.printf("移除头部元素[%d]后，剩余的元素为：%s", removeLastValue, linkedList);	//移除尾部元素[21]后，剩余的元素为：[7, 10, 11, 6]
        System.out.println();
        int size = linkedList.size();
        System.out.println("链表中的元素有：" + linkedList);    //链表中的元素有：[7, 10, 11, 6]
        System.out.println("链表中的大小为: " + size); //链表中的大小为: 4

        //以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的数组
        Integer[] array = linkedList.toArray(new Integer[0]);
        System.out.println("linkedList转换为数组：" + Arrays.toString(array));    //linkedList转换为数组：[7, 10, 11, 6]
        //清空链表
        linkedList.clear();
        System.out.println("链表清空后，里面的元素为：" + linkedList);   //链表清空后，里面的元素为：[]