java list move_Java中List最重要的特性

List(接口) 顺序是List最重要的特性;它可保证元素按照规定的顺序排列。List为Collection添加了大量方法，以便我们在List中部插入和删除元素(只推荐对LinkedList这样做)。List也会生成一个ListIterator(列表反复器)，利用它可在一个列表里朝两个方向遍历，同时插入和删除位于列表中部的元素(同样地，只建议对LinkedList这样做)

ArrayList* 由一个数组后推得到的List。作为一个常规用途的对象容器使用，用于替换原先的Vector。允许我们快速访问元素，但在从列表中部插入和删除元素时，速度却嫌稍慢。一般只应该用ListIterator对一个ArrayList进行向前和向后遍历，不要用它删除和插入元素;与LinkedList相比，它的效率要低许多

LinkedList 提供优化的顺序访问性能，同时可以高效率地在列表中部进行插入和删除操作。但在进行随机访问时，速度却相当慢，此时应换用ArrayList。也提供了addFirst()，addLast()，getFirst()，gETLast()，removeFirst()以及removeLast()(未在任何接口或基础类中定义)，以便将其作为一个规格、队列以及一个双向队列使用。

下面这个例子中的方法每个都覆盖了一组不同的行为：每个列表都能做的事情(basicTest())，通过一个反复器遍历(iterMotion())、用一个反复器改变某些东西(iterManipulation())、体验列表处理的效果(testVisual())以及只有LinkedList才能做的事情等：

//: List1.java

// Things you can do with Lists

package c08.newcollections;

import java.util.*;

public class List1 {

// Wrap Collection1.fill() for convenience:

public static List fill(List a) {

return (List)Collection1.fill(a);

}

// You can use an Iterator, just as with a

// Collection, but you can also use random

// Access with get():

public static void print(List a) {

for(int i = 0; i < a.size(); i++)

System.out.print(a.get(i) + " ");

System.out.println();

}

static boolean b;

static Object o;

static int i;

static Iterator it;

static ListIterator lit;

public static void basicTest(List a) {

a.add(1, "x"); // Add at location 1

a.add("x"); // Add at end

// Add a collection:

a.addAll(fill(new ArrayList()));

// Add a collection starting at location 3:

a.addAll(3, fill(new ArrayList()));

b = a.contains("1"); // Is it in there

// Is the entire collection in there

b = a.containsAll(fill(new ArrayList()));

// Lists allow random access, which is cheap

// for ArrayList, expensive for LinkedList:

o = a.get(1); // Get object at location 1

i = a.indexOf("1"); // Tell index of object

// indexOf, starting search at location 2:

i = a.indexOf("1", 2);

b = a.iSEMpty(); // Any elements inside

it = a.iterator(); // Ordinary Iterator

lit = a.listIterator(); // ListIterator

lit = a.listIterator(3); // Start at loc 3

i = a.lastIndexOf("1"); // Last match

i = a.lastIndexOf("1", 2); // ...after loc 2

a.remove(1); // Remove location 1

a.remove("3"); // Remove this object

a.set(1, "y"); // Set location 1 to "y"

// Keep everything that's in the argument

// (the intersection of the two sets):

a.retainAll(fill(new ArrayList()));

// Remove elements in this range:

a.removeRange(0, 2);

// Remove everything that's in the argument:

a.removeAll(fill(new ArrayList()));

i = a.size(); // How big is it

a.clear(); // Remove all elements

}

public static void iterMotion(List a) {

ListIterator it = a.listIterator();

b = it.hasNext();

b = it.hasPrevious();

o = it.next();

i = it.nextIndex();

o = it.previous();

i = it.previousIndex();

}

public static void iterManipulation(List a) {

ListIterator it = a.listIterator();

it.add("47");

// Must move to an element after add():

it.next();

// Remove the element that was just produced:

it.remove();

// Must move to an element after remove():

it.next();

// Change the element that was just produced:

it.set("47");

}

public static void testVisual(List a) {

print(a);

List b = new ArrayList();

fill(b);

System.out.print("b = ");

print(b);

a.addAll(b);

a.addAll(fill(new ArrayList()));

print(a);

// Shrink the list by removing all the

// elements beyond the first 1/2 of the list

System.out.println(a.size());

System.out.println(a.size()/2);

a.removeRange(a.size()/2, a.size()/2 + 2);

print(a);

// Insert, remove, and replace elements

// using a ListIterator:

ListIterator x = a.listIterator(a.size()/2);

x.add("one");

print(a);

System.out.println(x.next());

x.remove();

System.out.println(x.next());

x.set("47");

print(a);

// Traverse the list backwards:

x = a.listIterator(a.size());

while(x.hasPrevious())

System.out.print(x.previous() + " ");

System.out.println();

System.out.println("testVisual finished");

}

// There are some things that only

// LinkedLists can do:

public static void testLinkedList() {

LinkedList ll = new LinkedList();

Collection1.fill(ll, 5);

print(ll);

// Treat it like a stack, pushing:

ll.addFirst("one");

ll.addFirst("two");

print(ll);

// Like "peeking" at the top of a stack:

System.out.println(ll.getFirst());

// Like popping a stack:

System.out.println(ll.removeFirst());

System.out.println(ll.removeFirst());

// Treat it like a queue, pulling elements

// off the tail end:

System.out.println(ll.removeLast());

// With the above operations, it's a dequeue!

print(ll);

}

public static void main(String args[]) {

// Make and fill a new list each time:

basicTest(fill(new LinkedList()));

basicTest(fill(new ArrayList()));

iterMotion(fill(new LinkedList()));

iterMotion(fill(new ArrayList()));

iterManipulation(fill(new LinkedList()));

iterManipulation(fill(new ArrayList()));

testVisual(fill(new LinkedList()));

testLinkedList();

}

} ///:~

在basicTest()和iterMotiion()中，只是简单地发出调用，以便揭示出正确的语法。而且尽管捕获了返回值，但是并未使用它。在某些情况下，之所以不捕获返回值，是由于它们没有什么特别的用处。在正式使用它们前，应仔细研究一下自己的联机文档，掌握这些方法完整、正确的用法。