List中接口中的ArrayList和LinkedList

List

1.  List接口是Collection的子接口，可以将元素维护在特定的序列中；List在Collection基础上添加了大量的方法，使得可以再List中间插入和移除元素，并却List允许有重复元素出现，元素存入的顺序和取出的顺序一致。

2.List支持对元素的增，删，改，查；

（1）添加：

       add（index，element）：指定索引位置插入元素。

       addAll（index，collection）：在指定索引位置插入一堆元素。

（2）删除：

        remove(index)：删除指定索引的元素，返回被删的元素。

（3）获取：

        element get（index）：通过索引获取指定元素。

        int indexOf（element）：获取指定元素第一次出现的索引位置，如果该元素不存在则返回-1.

        int lastindexOf（element）：反向索引指定位置。

        List subList（start，end）：获取子列表。

（4）修改：

        element set（index，newEment）：对指定索引元素进行修改。

3.List接口又分为两种类型：ArrayList和LinkedList。

ArrayList:

1.ArrayList：底层是数组结构，长度可变，相当于一个可扩充的数组，线程不同步。增删速度慢，查询速度快。ArrayList是按照原数组的50%延长。构造一个初始容量为10的空列表。

可变长度数组的原理：不断new新数组并将原数组元素复制到新数组。当元素超出数组长度，会产生一个新数组，将原数组的数据复制到新数组中，再将新的元素添加到新数组中。

2.优点：数组结构的优点是便于对集合进行快速的随机访问，如果经常需要根据索引位置访问集合中的对象，使用由ArrayList类实现的List集合的效率较好。

3.缺点:向指定索引位置插入对象和删除指定索引位置对象的速度较慢，如果经常需要向List集合的指定索引位置插入对象，或者是删除List集合的指定索引位置的对象，使用由ArrayList类实现的List集合的效率则较低，并且插入或删除对象的索引位置越小效率越低，原因是当向指定的索引位置插入对象时，会同时将指定索引位置及之后的所有对象相应的向后移动一位。当删除指定索引位置的对象时，会同时将指定索引位置之后的所有对象相应的向前移动一位.

4.ArrayList类中的方法，下面以一段代码介绍：

import java.util.ArrayList;
import java.util.List;
public class TestList {
	public static void main(String[] args) {
		List<String> list=new ArrayList<String>();
		list.add("abcd");
		list.add("efgh");
		list.add("jklm");
		list.add("Word");
		list.add("Holle");
		list.add("Word");
		System.out.println(list);
		//list.remove("Holle");   //删除指定元素，删除之后集合的长度会改变
		//list.removeAll(list);   //删除集合的所有元素
		System.out.println(list.contains("Word"));  //判断集合中是否包含指定元素，底层是用equals实现的
		System.out.println(list.containsAll(list)); //集合中是否包含指定的多个元素
		System.out.println(list.indexOf("Word"));   //返回一个整数值，指出 String 对象内子字符串的开始位置，如果有重复的字符出现，以第一个字符为准。如果没有找到子字符串，则返回 -1。
		//list.clear();   //清空集合所有元素
		System.out.println(list.size());   //输出集合的长度
		System.out.println(list.isEmpty()); //判断集合中是否有元素
		list.toArray();						//将集合转成数组,也就是说把ArrayLiat()中的元素复制到数组中
		System.out.println (list);
	}
}

LinkedList:

1.LinkedList:底层数据结构是链表，线程不同步。增删速度快。查找速度慢（在内存中需要一个个查询，判断地址来寻找下一个元素）。可以利用LinkedList实现堆栈（先进后出），队列结构（先进先出）。

2.LinkedList的实现方法：

boolean       add(E object)  //在末尾增加一个元素
void          add(int location, E object) //在指定位置增加元素
boolean       addAll(Collection<? extends E> collection) //在末尾加入一组元素
boolean       addAll(int location, Collection<? extends E> collection) //从指定位置开始加一组元素
void          addFirst(E object) //在表头增加一个元素
void          addLast(E object) //在表尾增加一个元素
void          clear() //清空链表
Object        clone() //复制一个元素
boolean       contains(Object object) //判断是否包含object
Iterator<E>   descendingIterator() //逆序迭代器
E             element() //获取链表第一个元素,不存在会抛出异常
E             get(int location) //获取location位置的元素,不存在会抛出异常
E             getFirst() //获取链表第一个元素,不存在会抛出异常
E             getLast() //获取链表最后一个元素,不存在会抛出异常
int           indexOf(Object object) //获取object第一次出现的位置
int           lastIndexOf(Object object) //获取object最后一次出现的位置
ListIterator<E>     listIterator(int location) //从location开始的迭代器
boolean       offer(E o) //在末尾增加一个元素
boolean       offerFirst(E e) //在表头增加一个元素
boolean       offerLast(E e) //在表尾增加一个元素
E             peek() //获取表头元素,不存在不会抛出异常
E             peekFirst() //获取表头元素,不存在不会抛出异常
E             peekLast() //获取表尾元素,不存在不会抛出异常
E             poll() //弹出表头元素
E             pollFirst() //弹出表头元素
E             pollLast() //弹出表尾元素
E             pop() //弹出表头元素,不存在会抛异常
void          push(E e) //在表头增加一个元素
E             remove() //删除最后一个元素
E             remove(int location) //删除location位置的元素
boolean       remove(Object object) //删除第一个出现的object
E             removeFirst() //删除第一个元素
boolean       removeFirstOccurrence(Object o) //删除第一个出现的o
E             removeLast() //删除最后一个元素
boolean       removeLastOccurrence(Object o) //删除最后一个出现的o
E             set(int location, E object) //将location位置设置为object
int           size() //链表大小
<T> T[]       toArray(T[] contents) //转换为T类型的数组
Object[]     toArray() //转换为Object类型的数组

下面为代码运行程序：

import java.util.LinkedList;
public class TestLinkedList {
	public static void main(String[] args) {
		LinkedList<String> linkedlist=new LinkedList<String>();
		linkedlist.add("abcd");
		linkedlist.add("efgh");
		linkedlist.add("jklm");
		linkedlist.add("Word");
		linkedlist.add("Holle");
		linkedlist.add("Word");
		System.out.println("输出链表："+linkedlist);
		linkedlist.addFirst("Goog");
		System.out.println("插入头部后的链表："+linkedlist);    //将指定元素插入列表头部
		linkedlist.addLast("Kill");
		System.out.println("将‘Kill’插入尾部后的链表："+linkedlist);    //将指定元素插入列表的尾部
		System.out.println("输出第一个元素："+linkedlist.getFirst()); //得到第一个元素
		System.out.println("输出最后一个元素："+linkedlist.getLast());  //得到最后一个元素
		System.out.println("返回最后一个元素："+linkedlist.removeLast()); //移除列表并返回列表的最后一个元素
		System.out.println("返回第一个元素："+linkedlist.removeFirst());//移除列表并返回列表的第一个一个元素
		linkedlist.removeFirstOccurrence("Word");    //移除链表中指定第一次出现所在位置的元素
		System.out.println("移除后的链表：："+linkedlist);
		linkedlist.removeLastOccurrence("Holle");	//移除链表中指定元素最后一次出现所在位置的元素
		System.out.println("移除后的链表："+linkedlist);
		System.out.println("第三个下标的元素："+linkedlist.get(3));     //按下标获取元素
		System.out.println("第一个元素为："+linkedlist.getFirst());   //获取第一个元素
		System.out.println("最后一个元素为："+linkedlist.getLast());	//获取最后一个元素
		System.out.println("返回的第一个元素为"+linkedlist.pop());       //与removeFirst一样，删除列表并返回第一个元素，如果列表为空则产生异常
		System.out.println(linkedlist.poll());		//查询并移除第一个元素，列表为空返回null
		System.out.println(linkedlist.peek());      //获取第一个元素，但是不删除
		System.out.println("获取的第一个元素为："+linkedlist.peekFirst());//获取第一个元素，但是不删除
		System.out.println("获取的最后一个元素为："+linkedlist.peekLast());//获取最后一个元素，但是不删除
	}
}

运行结果：

3.LinkedList模拟堆栈存储方式：

import java.util.LinkedList;
class StackList{
	LinkedList<String> list;
	public StackList() {
		list=new LinkedList<String>();
	}
	public void add(String name) {  //进栈
		list.push(name);
	}
	public Object pop() {          //弹栈：把元素删除并返回
		return list.pop();
	}
	public int size() {
		return list.size();
	}
}
public class TestSteckList {

	public static void main(String[] args) {
		StackList l=new StackList();
		l.add("李四");
		l.add("李三");
		l.add("李二");
		int size=l.size(); 
		for(int i=0;i<size;i++) {
			System.out.println(l.pop());
		}
	}
}

运行结果：李二    李三    李四

4.使用LinkedList模拟队列存储方式：

import java.util.LinkedList;
class StList{
	LinkedList<String> list;
	public StList() {
		list=new LinkedList<String>();
	}
	public void add(String name) {  
		list.offer(name);
	}
	public Object pop() {         
		return list.poll();
	}
	public int size() {
		return list.size();
	}
}
public class TeamList {

	public static void main(String[] args) {
		StList l=new StList();
		l.add("李四");
		l.add("李三");
		l.add("李二");
		int size=l.size(); 
		for(int i=0;i<size;i++) {
			System.out.println(l.pop());
		}
	}
}

运行结果： 李四 李三 李二

ArrayList和LinkedList的区别：

1.在ArrayList的 中间插入或删除一个元素意味着这个列表中剩余的元素都会被移动；而在LinkedList的中间插入或删除一个元素的开销是固定的。

2..对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。

3.当操作是在一列数据的后面添加数据而不是在前面或中间,并且需要随机地访问其中的元素时,使用ArrayList会提供比较好的性能；当你的操作是在一列数据的前面或中间添加或删除数据,并且按照顺序访问其中的元素时,就应该使用LinkedList了。

4..对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。

5.ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。