Java链表类LinkedList

 Java提供了LinkedList链表类,它是实现了泛型接口List的泛型类,而泛型接口List又是Collection接口的子接口。所以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" );
	
		

	}

}

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

排序和查找

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

public static sort(List list) sort方法是面向Comparable接口设计的,所以要是用户自己编写的类,那就必须实现Comparable接口去定义对象的排序原则
public int binarySearch(List 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 list) 将list中的数据按照洗牌算法重新排列
static void rotate(List list , int distance) 将list元素旋转
public static void rexerse(List list) 将list元素翻转

你可能感兴趣的:(Java链表类LinkedList)