16.JAVA编程思想——使用Collections

16.JAVA编程思想——使用Collections

一个集合能做的所有事情（亦可对Set 和List 做同样的事情，尽管List还提供了一些额外的功能）。Map 不是从Collection 继承的，所以要单独对待。

boolean add(Object) ＊保证集合内包含了自变量。如果它没有添加自变量，就返回false（假）

boolean addAll(Collection) ＊添加自变量内的所有元素。如果没有添加元素，则返回true（真）

void clear() ＊删除集合内的所有元素

boolean contains(Object) 若集合包含自变量，就返回“真”

boolean containsAll(Collection) 若集合包含了自变量内的所有元素，就返回“真”

boolean isEmpty() 若集合内没有元素，就返回“真”

Iterator iterator() 返回一个反复器，以用它遍历集合的各元素

boolean remove(Object) ＊如自变量在集合里，就删除那个元素的一个实例。如果已进行了删除，就返回“真”

boolean removeAll(Collection) ＊删除自变量里的所有元素。如果已进行了任何删除，就返回“真”

boolean retainAll(Collection) ＊只保留包含在一个自变量里的元素（一个理论的“交集”）。如果已进行了任何改变，就返回“真”

int size() 返回集合内的元素数量

Object[] toArray() 返回包含了集合内所有元素的一个数组

＊这是一个“可选的”方法，有的集合可能并未实现它。若确实如此，该方法就会遇到一个

UnsupportedOperatiionException，即一个“操作不支持”违例，

1     代码如下：

import java.util.*;

 

public
class Collection1 {

    // Fill with'size' elements, start

 

    // counting at'start':

    public
staticCollection fill(Collection
c, int
start, int
size) {

        for (int
i =
start; i <
start + size;
i++)

            c.add(Integer.toString(i));

        return
c;

    }

 

    // Default toa "start" of 0:

    public
staticCollection fill(Collection
c, int
size) {

        return
fill(c, 0,
size);

    }

 

    // Default to10 elements:

    public
staticCollection fill(Collection
c) {

        return
fill(c, 0, 10);

    }

 

    // Create& upcast to Collection:

    public
staticCollection newCollection() {

        return
fill(new ArrayList());

        // ArrayList is used for simplicity, but it's

        // only seen as a generic Collection

        // everywhere else in the program.

    }

 

    // Fill aCollection with a range of values:

    public
staticCollection newCollection(int
start,intsize){

        return
fill(new ArrayList(),
start, size);

    }

 

    // Movingthrough a List with an iterator:

    public
staticvoidprint(Collection
c) {

        for (Iterator
x = c.iterator();
x.hasNext();)

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

        System.out.println();

    }

 

    public
staticvoidmain(String[]
args){

        Collection
c = newCollection();

        c.add("ten");

        c.add("eleven");

        print(c);

        // Make an array from the List:

        Object[] array =
c.toArray();

        // Make a String array from the List:

        String[] str = (String[])
c.toArray(new String[1]);

        // Find max and
min elements; this means

        // different things depending on the way

        // the Comparable interface is implemented:

        System.out.println("Collections.max(c) = "+
Collections.max(c));

        System.out.println("Collections.min(c) = "+
Collections.min(c));

        // Add a Collection to another Collection

 

        c.addAll(newCollection());

        print(c);

        c.remove("3");
// Removes the first one

        print(c);

        c.remove("3");
// Removes the second one

        print(c);

        // Remove all components that are in the

        // argument collection:

        c.removeAll(newCollection());

        print(c);

        c.addAll(newCollection());

        print(c);

        // Is an element in this Collection?

        System.out.println("c.contains(\"4\") = "+
c.contains("4"));

        // Is a Collection in this Collection?

        System.out.println("c.containsAll(newCollection()) = "+
c.containsAll(newCollection()));

        Collection
c2 = newCollection(5,3);

        // Keep all the elements that are in both

        // c and c2 (an intersection of sets):

        c.retainAll(c2);

        print(c);

        // Throw away all the elements in c that

        // also appear in c2:

        c.removeAll(c2);

        System.out.println("c.isEmpty() = " +
c.isEmpty());

        c =
newCollection();

        print(c);

        c.clear();
// Remove all elements

        System.out.println("after c.clear():");

        print(c);

    }

} ///

2     执行如下：

01 2 3 4 5 6 7 8 9 ten eleven

Collections.max(c)= ten

Collections.min(c)= 0

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

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

01 2 4 5 6 7 8 9 ten eleven 0 1 2 4 5 6 7 8 9

teneleven

teneleven 0 1 2 3 4 5 6 7 8 9

c.contains("4")= true

c.containsAll(newCollection())= true

56 7

c.isEmpty()= true

01 2 3 4 5 6 7 8 9

afterc.clear():

通过第一个方法，我们可用测试数据填充任何集合。在当前这种情况下，只是将int 转换成String。第二个方法将在本章其余的部分经常采用。

newCollection()的两个版本都创建了ArrayList，用于包含不同的数据集，并将它们作为集合对象返回。所以很明显，除了Collection 接口之外，不会再用到其他什么。

print()方法用一个反复器（Iterator）在一个集合内遍历，而任何集合都可以产生这样的一个反复器，适用于List 和Set，也适用于由一个Map 生成的Collection。

main()用简单的手段显示出了集合内的所有方法。

后续将比较List ，Set 和Map 的不同实现方案，同时指出在各种情况下哪一种方案应成为首选（带有星号的那个）。会发现这里并未包括一些传统的类，如Vector，Stack 以及Hashtable等。

不管在什么情况下，新集合内都有自己首选的类。