Collection,List和Set继承了该接口。List必须保证元素的顺序，而Set保证容器中没有重复元素。
Map没有继承Collection接口，只是使用Collection表示其中部分的内容。keySet方法返回由Set表示的键集合，values返回由Collection表示的值集合。entrySet返回由Set表示的键值对集合。
|
1，容器的打印
import java.util.*;
public class ContainerPrint{
static Collection fill(Collection c){
c.add("dog");
c.add("dog");
c.add("cat");
return c;
}
static Map fill(Map m){
m.put("dog","Bosco");
m.put("dog","Spot");
m.put("cat","Rags");
return m;
}
public static void main(String[] args){
List list=new ArrayList();
Set set=new HashSet();
Map m=new HashMap();
System.out.println(fill(list));
System.out.println(fill(set));
System.out.println(fill(m));
}
}
#输出：
[dog, dog, cat]
[cat, dog]
{cat=Rags, dog=Spot}
#List是可以包含重复元素的，而Set不能，并且List按对象进入容器的顺序保存对象，HashSet并不保证元素的顺序；HashMap保证了键的唯一性，若有重复键则最后加入的键值对覆盖之前的键值对，与Set相同它也不保证键值对的顺序。
若需要Set或者Map关心元素添加的顺序则可以使用LinkedHashSet或者LinkedHashMap.
|
2,填充容器
容器的填充与Arrays一样面临着不足。Collection提供了一些使用的static方法实现对容器的填充。但他们只对List有用对于Set或者Map则不起作用。
import java.util.*;
public class ContainerFill{
public static void main(String[] args){
//List list=new ArrayList();
List list=new ArrayList(10);
System.out.println(list.size());
System.out.println(list.get(3));
}
}
不要被API误导：
ArrayList（）
Constructs an empty list with an initial capacity of ten.
ArrayList(int)
Constructs an empty list with the specified initial capacity.
这里说的容量指的是容器在下一次扩展之前所能加入元素的最大个数。由于性能的原因底层的数组并未进行初始化。因此第一行打印为0，第二行打印语句抛出IndexOutOfBoundsException.
在对容器进行填充之前：
Collections.fill(list1,"hello");
System.out.println(list1);
将打印“[]”。可以发现Collections.fill实现的对容器的填充实质上是一种替换，及替换容器中已有的元素。
|
#Iterator.remove方法
import java.util.*;
class Mouse{
private int i;
Mouse(int i){
this.i=i;
}
public boolean equals(Object o){
if(i==((Mouse)o).i)
return true;
return false;
}
public String toString(){
return "Mouse# "+i;
}
}
public class ContainerFill{
public static void main(String[] args){
List list1=new ArrayList(10);
for(int i=0;i<5;i++)
list1.add(new Mouse(i));
Iterator iter=list1.iterator();
#删除第四个元素
while(iter.hasNext()){
if(iter.next().equals(new Mouse(3)))
iter.remove();
}
System.out.println(list1);
}
}
#[Mouse# 0, Mouse# 1, Mouse# 2, Mouse# 4]
|
#无意识造成的递归
import java.util.*;
public class InfiniteRecursion{
public String toString(){
return "InfiniteRecursion address "+this+"\n";
}
public static void main(String[] args){
List v=new ArrayList();
for(int i=0;i<10;i++)
v.add(new InfiniteRecursion());
System.out.println(v);
}
}
|
#Collection的功能方法
即可以通过Collection执行的所有操作。
boolean add(Object)
boolean addAll(Collection)
只要添加了任意元素就会返回true
void clear()
boolean contains(Object)
boolean containsAll(Collection)
boolean isEmpty()
Iterator iterator()
boolean remove(Object)
boolean removeAll(Collection)
只要有移除动作发生就返回true
boolean retainAll(Collection)
只保留参数中的元素
int size()
Object[] toArray()
Object[] toArray(Object[] a)
返回一个数组包含容器中所有元素，类型与a类型相同
import java.util.*;
public class CollectionDemo{
public static void main(String[] args){
Collection c1=new ArrayList();
Collection c2=new ArrayList();
for(int i=0;i<5;i++){
c1.add(""+i);
c2.add(""+(i+5));
}
System.out.
println(c1.contains("1"));
System.out.
println(c1.containsAll(c2));
c1.addAll(c2);
System.out.println(c1);
System.out.
println(c1.containsAll(c2));
c1.removeAll(c2);
System.out.println(c1);
c1.addAll(c2);
System.out.println(c1);
c1.retainAll(c2);
System.out.println(c1);
Object[] objs=(String[])c1.
toArray(new String[1]);
}
}
|
#List的功能方法
******
1，List生成的Iterator是ListIterator
2，ArrayList由数组实现，允许对元素进行快速随机访问，但是想ArrayList中间插入与移除元素的速度很慢。ListIterator应该用于遍历ArrayList，而不应该用于插入与移除元素。这样比LinkedList开销大很多。
3，向List中间插入与删除元素开销不大，随机访问的速度较慢。还具有方法addFirst(),addLast(),getFirst()
getLast(),removeFirst(),removeLast().这使得LinkedList可以当作堆栈，队列和双向队列使用。
******
ArrayList与LinkedList都实现了不同版本的add与addAll方法：
add(Object)|add(int index,Object)
addAll(Collection)
addAll(int index,Collection)
其它常用的方法：
indexOf(Object)
lastIndexOf(Object)
#使用ListIterator:
import java.util.*;
public class ListIteratorDemo{
public static void main(String[] args){
List lt=new ArrayList();
for(int i=0;i<5;i++)
lt.add(new Integer(i));
Iterator iter1=lt.listIterator();
Iterator iter2=lt.listIterator(2);
#迭代器停在最后一个元素之后
ListIterator iter3=lt.
listIterator(lt.size());
while(iter1.hasNext())
System.out.print(
iter1.next()+" ");
System.out.println();
while(iter2.hasNext())
System.out.print(iter2.next()
+" ");
System.out.println();
#这里证明List采用的index方式与array一致
while(iter3.hasPrevious())
System.out.print(
"[index "+iter3.previousIndex()
+" : "+"
value "+iter3.previous()+
" ] ");
System.out.println();
}
}
|
#使用Set
HashSet，为快速查找而设计的Set存入HashSet的对象必须定义hashCode();
TreeSet，保持次序的Set，但不是元素的插入顺序。底层使用树结构。
LinkedHashSet，具有HashSet的查询速度，内部使用链表维护元素的顺序。于是在使用Iterator遍历Set时会按插入顺序显示。
#SetDemo.java
import java.util.*;
class MyType{
private int i;
MyType(int i){
this.i=i;
}
public String toString(){
return "[MyType "+i+"]";
}
}
public class SetDemo{
public static void main(String[] args){
Set st=new HashSet();
st.add(new Integer(1));
st.add(new Integer(1));
System.out.println(st);
st.clear();
st.add(new MyType(1));
st.add(new MyType(1));
System.out.println(st);
}
}
#输出：
[1]
[[MyType 1], [MyType 1]]
可以看到Set在确定插入的元素是否已经存在时采用的是基于内容的比较，而不是引用的比较。由于MyType采用了Object基类中默认的equals实现，这是基于引用的比较的。
另外Map也有类似的特性:
package com.biaoflying;
import java.util.*;
class MyType{
int i;
MyType(int i){
this.i=i;
}
public String toString(){
return "[MyType "+i+"]";
}
}
public class MapDemo{
public static void main(String[] args){
Map hashMap=new HashMap();
hashMap.put(new Integer(1),
new MyType(1));
hashMap.put(new Integer(1),
new MyType(1));
hashMap.put(new MyType(1),
new Integer(1));
hashMap.put(new MyType(1),
new Integer(1));
System.out.println(hashMap);
}
}
#输出：
{1=[MyType 1], [MyType 1]=1, [MyType 1]=1}
查看并使用SortedSet
|
|
阅读(731) | 评论(0) | 转发(0) |
