Java链表类LinkedList

 Java提供了LinkedList<E>链表类，它是实现了泛型接口List<E>的泛型类，而泛型接口List<E>又是Collection<E>接口的子接口。所以LinkedList泛型类里的方法大多都是泛型接口方法的实现。
我们可以利用接口回调把LinkedList对象赋值给List或者Collection接口对象，接口就可以直接调用类实现的接口方法。
下面看看定义方法：

package sfdsf;

import java.util.Collection;
import java.util.LinkedList;
import java.util.List;

public class Test
{

	public static void main(String[] args)
	{
		LinkedList<String> list = new LinkedList<String>();
		List<String> list1 = new LinkedList<String>();
		Collection<String> list2 = new LinkedList<String>();

	}

}

LinkedList类的主要方法

LinkedList类	主要方法
public boolean add(E element)	向链表末尾增加一个节点，节点数据是element
public void add(int index , E element)	向链表指定位置增加一个节点，节点数据是element
public void clear()	删除链表所有结点
public E get(int index)	返回指定结点上的数据
public int size()	返回链表的结点个数
public boolean contains(Object element)	判断链表中是否含有该数据的结点
public Object clone()	返回当前链表的有个克隆链表

遍历链表

对于LinkedList的遍历有两种方法：

1. 利用迭代器
2. 利用LinkedList的get方法

注意：利用迭代器方法比get方法更快

下面看看例子：

package sfdsf;

import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

public class Test
{


	public static void main(String[] args)
	{
		LinkedList<String> list = new LinkedList<String>();
		for (int i=0 ; i<10000 ; i++)
			list.add(i + "speed");

		//迭代器遍历LinkedList
		Iterator<String> iterator = list.iterator();
		long startTime = System.currentTimeMillis();
		while(iterator.hasNext())
			 iterator.next();
		long endtTime = System.currentTimeMillis();
		System.out.println("迭代器遍历时间为：" + (endtTime- startTime) + "ms" );
	
		//get方法遍历
		long startTime1 = System.currentTimeMillis();
		for (int i=0 ; i<list.size(); i++)
			 list.get(i);
		long endtTime1 = System.currentTimeMillis();
		System.out.println("get方法遍历时间为：" + (endtTime1- startTime1) + "ms" );
	
		

	}

}

这里简单提一下ArrayList类，它是一种顺序存储的动态数组表类。但是由于本质是数组，所以他不适合增加或者删除元素(比LinkedList要慢)，但是他获取第n个单元的元素要比LinkedList块。两者的本质区别就是一个是顺序存储，一个是链式存储，其他的方法差不多。

排序和查找

 Collections类提供了用于查找和排序的方法：

public static sort(List<E> list)	sort方法是面向Comparable接口设计的，所以要是用户自己编写的类，那就必须实现Comparable接口去定义对象的排序原则
public int binarySearch(List<E> list , T key , CompaerTo c)	二分查找list中是否含有和key相等的元素：有就返回位置索引；没有返回-1(原理和sort差不多，也是要实现Comparable接口)

下面举个例子，排序学生对象:

package sfdsf;


import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedList;



public class Test
{
	


	public static void main(String[] args)
	{
		LinkedList<Student> list = new LinkedList<Student>();
		
		list.add(new Student("小红" , 20));
		list.add(new Student("小明" , 21));
		list.add(new Student("小张" , 19));
		list.add(new Student("小刚" , 22));
		list.add(new Student("小李" , 23));
		list.add(new Student("小王" , 18));
		
		Iterator itrIterator = list.iterator();
		
		System.out.println("排序前：");
		while(itrIterator.hasNext())
		{
			System.out.println(itrIterator.next().toString());
		}
		Collections.sort(list);
		itrIterator = list.iterator();
		System.out.println("排序后：");
		while(itrIterator.hasNext())
		{
			System.out.println(itrIterator.next().toString());
		}

	}

} 
class Student  implements Comparable
{
	  String name;
	  int age;
	
	public Student(String name , int age)
	{
		this.name = name;
		this.age = age;
	}

	/*
	 * 定义年龄为排序基础
	 */
	@Override
	public int compareTo(Object o)
	{
		Student stu1 = (Student) o;
		return (this.age - stu1.age);
	}
	
	public String toString()
	{
		return ("名字：" + this.name + "，年龄：" + this.age);
	}
	
	
}

Collections类还提供了一些其他的方法：

public static void shuffle(List<E> list)	将list中的数据按照洗牌算法重新排列
static void rotate(List<E> list , int distance)	将list元素旋转
public static void rexerse(List<E> list)	将list元素翻转