17.JAVA编程思想——使用Lists

17.JAVA编程思想——使用Lists

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 才能做的事情等：

1     代码如下：

import java.util.*;

public
class List1 {

    // WrapCollection1.fill() for convenience:

    public
staticList fill(List
a) {

        return (List) Collection1.fill(a);

    }

    // You can usean Iterator, just as with a

    // Collection,but you can also use random

    // access withget():

    public
staticvoidprint(List
a){

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

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

        System.out.println();

    }

    static
booleanb;

    static Object
o;

    static
inti;

    static
Iterator it;

    static
ListIterator lit;

    public
staticvoidbasicTest(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 loc3

        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
staticvoiditerMotion(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
staticvoiditerManipulation(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
staticvoidtestVisual(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 aresome things that only

    // LinkedListscan do:

    public
staticvoidtestLinkedList() {

        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
staticvoidmain(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();

    }

} /// :~

2     执行如下

01 2 3 4 5 6 7 8 9

b= 0 1 2 3 4 5 6 7 8 9

01 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9

30

15

01 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9

01 2 3 4 5 6 7 8 9 0 1 2 3 4 one 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9

5

6

01 2 3 4 5 6 7 8 9 0 1 2 3 4 one 47 7 8 9 0 1 2 3 4 5 6 7 8 9

98 7 6 5 4 3 2 1 0 9 8 7 47 one 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0

testVisualfinished

01 2 3 4

twoone 0 1 2 3 4

two

two

one

4

01 2 3

3     代码解释

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