//使用clear()方法删除链表中的元素
        LinkedList<Integer> list = new LinkedList<Integer>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        System.out.println(list);
        list.subList(2,4).clear();
        System.out.println(list);

使用 top() 和 pop() 方法来获取链表的元素

import java.util.LinkedList;

public class Test {
    private static LinkedList list = new LinkedList();
    public static void push(Object o){
        list.addFirst(o);
    }
    public static Object top(){
        return list.getFirst();
    }
    public static Object pop(){
        return list.removeFirst();
    }
    public static void main(String[] args) {
       
        for (int i = 0; i < 10; i++) {
            list.push(i);
        }
        System.out.println(top());
        System.out.println(pop());
        System.out.println(pop());
        System.out.println(pop());


    }

使用 Collections 类的 sort() 方法对向量进行排序并使用 binarySearch() 方法来获取向量元素的索引值：

public static void main(String[] args) {
        Vector v = new Vector();
        v.add("A");
        v.add("E");
        v.add("D");
        v.add("P");
        v.add("G");
        Collections.sort(v);
        System.out.println(v);
        System.out.println(" D index : " + Collections.binarySearch(v, "D"));

    }

1.链表的概念

• 链表是一种动态数据结构，他的特点是用一组任意的存储单元（可以是连续的，也可以是不连续的）存放 数据元素。
• 链表中每一个元素成为 “结点” ， 每一个结点都是由数据域和指针域组成的， 每个结点中的指针域指向下一 个结点。
• Head 是 “头指针” ， 表示链表的开始， 用来指向第一个结点， 而最后一个指针的指针域为 NULL( 空地址 ) ，表示链表的结束。
• 可以看出链表结构必须利用指针才能实现，即一个结点中必须包含一个指针变量，用来存放下一个结点的 地址。 实际上，链表中的每个结点可以用若干个数据和若干个指针。

单链表：结点中只有一个指针的链表称为单链表，这是最简单的链表结构。
其节点由两部分构成：

• data域：数据域，用来存储元素数据
• next域：用于指向下一节点
  

双链表：有前后两个指针的链表。
其节点由三部分构成：

• data域：数据域，用来存储元素数据
• next域：用于指向后一节点
• front域：用于指向前一节点
  

2.链表的操作

2.1 单链表的操作

2.1.1 插入节点

单链表插入节点主要分两步，顺序不可替换：

1.先将x->next指向A2
2.再将A1->next指向x

2.1.2 删除节点

删除节点其实只需要一步

A1->next 指向A3就行，此时A2会被自动回收

2.1.3 单链表的缺点

通过对单链表的分析，可以看出单链表有如下缺点：

1. 单链表的查找方法只能是一个方向
2. 单链表不能自我删除，需要靠上一节点进行辅助操作。

2.2 双链表的操作

2.2.1 插入节点

双链表的操作会比单链表复杂很多，顺序也可以是2143，其他的可以自己想一想，只要不断就行。

1. x->next指向A2
2. A1->next指向x
3. x->prev指向A1
4. A2->prev指向x
   

2.2.2 删除节点

删除节点容易很多，先后顺序也不是很重要

A3->prev指向A1
A1->next指向A3

3.Java中链表的使用

以下内容参考Java LinkedList。更详细可以去这里看。
现在来讲Java要用到链表应该怎么写。

ArrayList和LinkedList都实现了链表，两者的区别在于与 ArrayList 相比，LinkedList 的增加和删除的操作效率更高，而查找和修改的操作效率较低。

链表用LinkedList较多。

3.1 Java中链表的操作

LinkedList 类位于 java.util 包中，使用前需要引入它，语法格式如下：

// 引入 LinkedList 类
import java.util.LinkedList; 

LinkedList<E> list = new LinkedList<E>();   // 普通创建方法
或者
LinkedList<E> list = new LinkedList(Collection<? extends E> c); // 使用集合创建链表

创建一个简单的链表实例：

import java.util.LinkedList;

public class RunoobTest {
    public static void main(String[] args) {
        LinkedList<String> sites = new LinkedList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Weibo");
        System.out.println(sites);
    }
}

以上实例，执行输出结果为：

[Google, Runoob, Taobao, Weibo]

其他操作可参考这个表格

3.2 Java实现链表

想看Java中链表是如何实现以及基本的操作可以看这个博客，讲的很清楚，我就不在这里贴代码了。java ListNode 链表

单链表：即单向链表，只能通过一个方向去遍历链表，由数据域（data）和指针域（next）组成。节点与节点之间通过指针来连接，每个节点指向自身的下一个节点，头节点为head，它的前一个节点为空；尾节点的下一个节点为null；结构如下图：

创建节点类，设置数据域和指针域，添加get和set方法

public class SingleLinkedNode {
    // 数据域
    private int data;
    // 指针域
    private SingleLinkedNode next;

    public SingleLinkedNode() {

    }

    public int getData() {
        return data;
    }

    public void setData(int data) {
        this.data = data;
    }

    public SingleLinkedNode getNext() {
        return next;
    }

    public void setNext(SingleLinkedNode next) {
        this.next = next;
    }
}

创建链表head，实现链表的遍历，新增，删除，查找操作。

    public class MyLinkedList {

    /**
     * 在指定位置添加节点
     *
     * @param pointNode 指定位置之后插入节点
     * @param newNode   即将插入的节点
     */
    public static void insert(SingleLinkedNode pointNode, SingleLinkedNode newNode) {
        SingleLinkedNode next = pointNode.getNext();// 记录插入节点pointNode的下一个结点
        pointNode.setNext(newNode);//pointNode的next指向新结点
        newNode.setNext(next);//把pointNode结点的next指向新节点的next结点
        System.out.println("插入节点node6成功！");
    }

    /**
     * 遍历
     *
     * @param head 链表
     */
    public static void query(SingleLinkedNode head) {
        while (head != null) {
            System.out.print(head.getData() + " ");
            head = head.getNext();
        }
        System.out.println();
    }

    /**
     * 查找数据
     *
     * @param head
     * @param data
     */
    public static void findData(SingleLinkedNode head, int data) {
        while (head != null) {
            if (head.getData() == data) {
                System.out.println("成功找到data:" + data);
                return;
            }
            head = head.getNext();
        }
        System.out.println("未找到data:" + data);
    }

    /**
     * 删除结点q
     *
     * @param head 链表
     * @param q       删除的结点
     */
    public static void delete(SingleLinkedNode head, SingleLinkedNode q) {
        // q不为空，q的下一个结点也不为空
        if (q != null && q.getNext() != null) {
            // 思路：把q与q的next交换，交换后直接指向q的next的next，q就被删除了
            SingleLinkedNode p = q.getNext();
            q.setData(p.getData());
            q.setNext(p.getNext());
        }
        // 删除最后一个节点
        if(q.getNext() == null) {
            while (head != null) {
                // 遍历前面的链表，当该节点的next就是q的时候
                // 然后把q设置成null
                if (head.getNext() != null && head.getNext() == q) {
                    head.setNext(null);
                    break;
                }
                head = head.getNext();
            }

        }
    }


    public static void main(String[] args) {
        SingleLinkedNode node1 = new SingleLinkedNode();
        node1.setData(0);
        SingleLinkedNode node2 = new SingleLinkedNode();
        node2.setData(1);
        SingleLinkedNode node3 = new SingleLinkedNode();
        node3.setData(2);
        SingleLinkedNode node4 = new SingleLinkedNode();
        node4.setData(3);
        SingleLinkedNode node5 = new SingleLinkedNode();
        node5.setData(4);
        node1.setNext(node2);
        node2.setNext(node3);
        node3.setNext(node4);
        node4.setNext(node5);
        node5.setNext(null);
        // 遍历链表
        query(node1);
        // node3 之后插入链表node6
        SingleLinkedNode node6 = new SingleLinkedNode();
        node6.setData(6);
        insert(node3, node6);
        query(node1);
        // 在链表中查找数据4
        findData(node1, 4);
        // 删除节点node3
        delete(node1, node3);
        query(node1);
    }
}