Java LinkedList基本用法

linkedlist类是双向列表,列表中的每个节点都包含了对前一个和后一个元素的引用.

linkedlist的构造函数如下

1. public linkedlist():  ——生成空的链表

2. public linkedlist(collection col):  复制构造函数

1、获取链表的第一个和最后一个元素

[java] view

plaincopy

import java.util.linkedlist;  

public class linkedlisttest{  

  public static void main(string[] args) {  

    linkedlist<string> llist = new linkedlist<string>();  

    llist.add("1");  

    llist.add("2");  

    llist.add("3");  

    llist.add("4");  

    llist.add("5");  

    system.out.println("链表的第一个元素是 : " + llist.getfirst());  

    system.out.println("链表最后一个元素是 : " + llist.getlast());  

  }  

}  

2、获取链表元素  

for (string str: llist) {  

      system.out.println(str);  

    }  

3、从链表生成子表

list subl = llist.sublist(1, 4);  

    system.out.println(subl);  

    lst.remove(2);  

    system.out.println(lst);  

    system.out.println(llist);  

4、添加元素：添加单个元素

 如果不指定索引的话，元素将被添加到链表的最后.

public boolean add(object element)

public boolean add(int index, object element)

也可以把链表当初栈或者队列来处理:

public boolean addfirst(object element)

public boolean addlast(object element)

addlast()方法和不带索引的add()方法实现的效果一样.

  public static void main(string[] a) {  

    linkedlist list = new linkedlist();  

    list.add("a");  

    list.add("b");  

    list.add("c");  

    list.add("d");  

    list.addfirst("x");  

    list.addlast("z");  

    system.out.println(list);  

5、删除元素

public object removefirst()  

public object removelast()  

public class mainclass {  

    list.removefirst();  

    list.removelast();  

6、使用链表实现栈效果

    stackl stack = new stackl();  

    for (int i = 0; i < 10; i++)  

      stack.push(i);  

    system.out.println(stack.top());  

    system.out.println(stack.pop());  

class stackl {  

  private linkedlist list = new linkedlist();  

  public void push(object v) {  

    list.addfirst(v);  

  public object top() {  

    return list.getfirst();  

  public object pop() {  

    return list.removefirst();  

7、使用链表来实现队列效果

    queue queue = new queue();  

      queue.put(integer.tostring(i));  

    while (!queue.isempty())  

      system.out.println(queue.get());  

class queue {  

  public void put(object v) {  

  public object get() {  

    return list.removelast();  

  public boolean isempty() {  

    return list.isempty();  

8、将linkedlist转换成arraylist

arraylist<string> arraylist = new arraylist<string>(linkedlist);  

    for (string s : arraylist) {  

      system.out.println("s = " + s);  

9、删掉所有元素：清空linkedlist

    llist.clear();

10、删除列表的首位元素

public class main {  

        //元素在删除的时候，仍然可以获取到元素  

    object object = llist.removefirst();  

    system.out.println(object + " has been removed");  

    object = llist.removelast();  

11、根据范围删除列表元素

    llist.sublist(2, 5).clear();  

12、删除链表的特定元素

    system.out.println(llist.remove("2"));//删除元素值=2的元素  

    object obj = llist.remove(2);  //删除第二个元素  

    system.out.println(obj + " 已经从链表删除");  

13、将linkedlist转换为数组，数组长度为0

import java.util.list;  

    list<string> thelist = new linkedlist<string>();  

    thelist.add("a");  

    thelist.add("b");  

    thelist.add("c");  

    thelist.add("d");  

    string[] my = thelist.toarray(new string[0]);  

    for (int i = 0; i < my.length; i++) {  

      system.out.println(my[i]);  

14、将linkedlist转换为数组，数组长度为链表长度

    string[] my = thelist.toarray(new string[thelist.size()]);  

15、将linkedlist转换成arraylist

import java.util.arraylist;  

    linkedlist<string> myqueue = new linkedlist<string>();  

    myqueue.add("a");  

    myqueue.add("b");  

    myqueue.add("c");  

    myqueue.add("d");  

    list<string> mylist = new arraylist<string>(myqueue);  

    for (object thefruit : mylist)  

      system.out.println(thefruit);  

16、实现栈

import java.util.collections;  

  public static void main(string[] argv) throws exception {  

    linkedlist stack = new linkedlist();  

    object object = "";  

    stack.addfirst(object);  

    object o = stack.getfirst();  

    stack = (linkedlist) collections.synchronizedlist(stack);  

17、实现队列

    linkedlist queue = new linkedlist();  

    // add to end of queue  

    queue.add(object);  

    // get head of queue  

    object o = queue.removefirst();  

18 、同步方法

    queue = (linkedlist) collections.synchronizedlist(queue);  

19、查找元素位置

    system.out.println(llist.indexof("2"));  

    system.out.println(llist.lastindexof("2"));  

20、替换元素

    llist.set(3, "replaced");//使用set方法替换元素，方法的第一个参数是元素索引，后一个是替换值  

21、链表添加对象

class address {  

  private string name;  

  private string street;  

  private string city;  

  private string state;  

  private string code;  

  address(string n, string s, string c, string st, string cd) {  

    name = n;  

    street = s;  

    city = c;  

    state = st;  

    code = cd;  

  public string tostring() {  

    return name + " " + street + " " + city + " " + state + " " + code;  

class maillist {  

  public static void main(string args[]) {  

    linkedlist<address> ml = new linkedlist<address>();  

    ml.add(new address("a", "11 ave", "u", "il", "11111"));  

    ml.add(new address("r", "11 lane", "m", "il", "22222"));  

    ml.add(new address("t", "8 st", "c", "il", "33333"));  

    for (address element : ml)  

      system.out.println(element + "\n");  

22、确认链表是否存在特定元素

    if (llist.contains("4")) {  

      system.out.println("linkedlist contains 4");  

    } else {  

      system.out.println("linkedlist does not contain 4");  

23、根据链表元素生成对象数组

object[] objarray = llist.toarray();  

for (object obj: objarray) {  

   system.out.println(obj);  

24、链表多线程

class prepareproduction implements runnable {  

  private final list<string> queue;  

  prepareproduction(list<string> q) {  

    queue = q;  

  public void run() {  

    queue.add("1");  

    queue.add("done");  

class doproduction implements runnable {  

  doproduction(list<string> q) {  

    string value = queue.remove(0);  

    while (!value.equals("*")) {  

      system.out.println(value);  

      value = queue.remove(0);  

  public static void main(string[] args) throws exception {  

    list q = collections.synchronizedlist(new linkedlist<string>());  

    thread p1 = new thread(new prepareproduction(q));  

    thread c1 = new thread(new doproduction(q));  

    p1.start();  

    c1.start();  

    p1.join();  

    c1.join();  

25、优先级链表（来自jboss）

import java.util.listiterator;  

import java.util.nosuchelementexception;  

public class basicprioritylinkedlist {  

  protected linkedlist[] linkedlists;  

  protected int priorities;  

  protected int size;  

  public basicprioritylinkedlist(int priorities) {  

    this.priorities = priorities;  

    initdeques();  

  public void addfirst(object obj, int priority) {  

    linkedlists[priority].addfirst(obj);  

    size++;  

  public void addlast(object obj, int priority) {  

    linkedlists[priority].addlast(obj);  

  public object removefirst() {  

    object obj = null;  

    for (int i = priorities - 1; i >= 0; i--) {  

      linkedlist ll = linkedlists[i];  

      if (!ll.isempty()) {  

        obj = ll.removefirst();  

        break;  

      }  

    if (obj != null) {  

      size--;  

    return obj;  

  public object removelast() {  

    for (int i = 0; i < priorities; i++) {  

        obj = ll.removelast();  

      if (obj != null) {  

  public object peekfirst() {  

        obj = ll.getfirst();  

  public list getall() {  

    list all = new arraylist();  

      linkedlist deque = linkedlists[i];  

      all.addall(deque);  

    return all;  

  public void clear() {  

  public int size() {  

    return size;  

    return size == 0;  

  public listiterator iterator() {  

    return new prioritylinkedlistiterator(linkedlists);  

  protected void initdeques() {  

    linkedlists = new linkedlist[priorities];  

      linkedlists[i] = new linkedlist();  

    size = 0;  

  class prioritylinkedlistiterator implements listiterator {  

    private linkedlist[] lists;  

    private int index;  

    private listiterator currentiter;  

    prioritylinkedlistiterator(linkedlist[] lists) {  

      this.lists = lists;  

      index = lists.length - 1;  

      currentiter = lists[index].listiterator();  

    public void add(object arg0) {  

      throw new unsupportedoperationexception();  

    public boolean hasnext() {  

      if (currentiter.hasnext()) {  

        return true;  

      while (index >= 0) {  

        if (index == 0 || currentiter.hasnext()) {  

          break;  

        }  

        index--;  

        currentiter = lists[index].listiterator();  

      return currentiter.hasnext();  

    public boolean hasprevious() {  

    public object next() {  

      if (!hasnext()) {  

        throw new nosuchelementexception();  

      return currentiter.next();  

    public int nextindex() {  

    public object previous() {  

    public int previousindex() {  

    public void remove() {  

      currentiter.remove();  

    public void set(object obj) {  

26、生成list的帮助类（来自google）

public class lists {  

  private lists() { }  

  public static <e> arraylist<e> newarraylist() {  

    return new arraylist<e>();  

  public static <e> arraylist<e> newarraylistwithcapacity(int initialcapacity) {  

    return new arraylist<e>(initialcapacity);  

  public static <e> arraylist<e> newarraylist(e... elements) {  

    arraylist<e> set = newarraylist();  

    collections.addall(set, elements);  

    return set;  

  public static <e> arraylist<e> newarraylist(iterable<? extends e> elements) {  

    arraylist<e> list = newarraylist();  

    for(e e : elements) {  

      list.add(e);  

    return list;  

  public static <e> linkedlist<e> newlinkedlist() {  

    return new linkedlist<e>();  

}