九、java容器

目录

一、容器的概念

二、Cpllection接口

三、Iterator接口

四、增强的for循环

五、Set接口

六、List接口和Comparable接口

八、Map接口

九、自动打包/解包

十、泛型（JDK1.5以后新增）

一、容器的概念和容器API

容器：java API所提供的一系列的实例，用于在程序中存放对象

JDK所提供的容器API位于java.util包内

容器API的类图结构如下图所示：

左边的容器都是一个个往里装，右边的容器也就是map这一边的是一对一对往里装

Collection接口定义了存取一组对象的方法，他代表了一个集合，他下面分了两个子接口set和list。

装东西的时候set是没有顺序并且不可以重复，list是有顺序可以重复，所谓的重复是指两个对象equals

Map接口定义了存储“键(key) –值(value)”  映射对的方法

二、Collection接口

• Collection接口中所定义的方法：

int size();
boolean isEmpty();
void clear();
boolean contains(Object element);//查看是否包含某一个对象
bllean add(Object element);
boolean remove(Object element);
Iterator iterator();
boolean containsAll(collection c);
bllean addAll(Collection c);
boolean removeAll(Collection c);
boolean retainAll(Collection c);//交集
object[] toArray();

看一个例子：

public class Test{
    
    public static void main(String[] args) {
        Collection c = new ArrayList();//父类引用指向子类对象
        //可以放入不同类型的对象
        c.add("hello");
        c.add(new Name("f1","l1"));
        c.add(new Integer(100));        
        System.out.println(c.size());
        System.out.println(c);
    }    
    
}
//输出结果：
//3
//[hello, f1 l1, 100]

public class Test{
    
    public static void main(String[] args) {
        Collection c = new ArrayList();
        c.add("hello");
        c.add(new Name("f1","l1"));
        c.add(new Integer(100));
        c.remove("hello");
        c.remove(new Integer(100));
        System.out.println(c.remove(new Name("f1","l1")));
        System.out.println(c);
    }        
}
//输出结果：
//false
//[f1 l1]
//因为两个Name("f1","l1")指向的不是同一个对象，所以equals方法返回false

容器类对象在调用remove、contains等方法时需要比较对象是否相等，这回涉及到对象类型的equals方法和hashCode方法；对于自定义的类 型，需要重写equals和hashCode方法以实现自定义的对象相等规则

注意：相等的对象应该具有相等的hashCode

增加Name类的equals和hashCode方法如下：

public boolean equals(Object obj) {
    if (obj instanceof Name) {
        Name name = (Name) obj;
        return (firstName.equals(name.firstName))&&(lastName.equals(name.lastName));
    }
    return super.equals(obj);
}
public int hashCode() {
    return firstName.hashCode();
}

这样那个例子代码结果就会变为true 和[]了

三、Iterator接口 

• 所有实现了collection接口的容器类都由一个interator方法用以返回一个实现了Interator接口的对象
• Interator对象称作迭代器，用以方便的实现对容器内元素的遍历操作
• Iterator接口定义了如下方法：

boolean hasNext();//判断游标右边是否有元素

Object next();//返回游标右边的元素并将游标移动到下一个位置

void remove();//删除游标左面的元素，在执行完next之后

看一个例子：

public class Test{
    
    public static void main(String[] args) {
        
        Collection c = new HashSet();
        c.add(new Name("f1","l1"));
        c.add(new Name("f2","l2"));
        c.add(new Name("f3","l3"));
        //遍历
        Iterator i = c.iterator();
        while(i.hasNext()) {
            //由于next()的返回值为Object类型，需要转换为相应类型
            Name n = (Name)i.next();
            System.out.print(n.getFirstName()+" ");
        }        
    }
}

//输出结果
//f1 f2 f3

• Iterator对象的remove方法是在迭代过程中删除元素的唯一的安全方法

public class Test{
    
    public static void main(String[] args) {
        
        Collection c = new HashSet();
        c.add(new Name("ffff1","lllll1"));
        c.add(new Name("f2","l2"));
        c.add(new Name("fff3","llll3"));
        
        for (Iterator i = c.iterator(); i.hasNext();) {
            Name name = (Name)i.next();
            if (name.getFirstName().length()<3) {
                i.remove();
                //如果换成c.remove(name);会产生例外
            }
        }
        
        System.out.println(c);
    }
}

//输出结果：[fff3 llll3, ffff1 lllll1]

四、增强的for循环

增强的for循环对于遍历array或Collection的时候非常简便

看一个例子先：

public class Test{
    
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        for(int i : arr) {
            System.out.print(i + " ");//遍历输出
        }
        
        System.out.println();
        
        Collection c = new ArrayList();
        c.add(new String("aaa"));
        c.add(new String("bbb"));
        c.add(new String("vvv"));
        for (Object o : c) {
            System.out.print(o + " ");//遍历输出
        }
    }
}

缺陷：

• 对于数组来说不能方便的访问下标值
• 对于集合来说，与使用Iterator来说，不能方便的删除集合中的内容（在for循环内部也调用Itertor）

所以，除了简单遍历并读出其中的内容外，不建议使用增强for

五、Set接口

Set接口是Collection的子接口，Set接口没有提供额外的方法，但实现Set接口的容器类中的元素是没有有顺序的，而且不可以重复

Set容器可以与数学中的集合的概念相对应

J2SDK 的API中所提供的Set容器类有HashSwt，TreeSet等

看一个例子：

public class Test{
    
    public static void main(String[] args) {
        
        Set s = new HashSet();
        s.add("hello");
        s.add("world");
        s.add(new Name("f1", "l1"));
        s.add(new Integer(100));
        s.add(new Name("f1", "l1"));//相同元素不会被加入
        s.add("hello");//相同元素不会被加入
        System.out.print(s + "    ");
    }
}
//输出结果：[world, 100, hello, f1 l1]

再看一个例子：

public class Test{
    
    public static void main(String[] args) {
        
        Set s1 = new HashSet();
        Set s2 = new HashSet();
        
        s1.add("a");
        s1.add("b");
        s1.add("c");
        
        s2.add("a");
        s2.add("b");
        s2.add("d");
        
        Set sn = new HashSet(s1);
        sn.retainAll(s2);//交集 
        Set su = new HashSet(s1);
        su.addAll(s2);
        
        System.out.println("su = "+ su);
        System.out.println("sn = "+ sn);
        
    }
}
//输出结果：
//su = [a, b, c, d]
//sn = [a, b]

六、List接口和Comparable接口

1.List接口

List接口是Collection的子接口，实现List接口的俄容器类中的元素是有顺序的，而且可以重复

List的容器重点额元素都对应一个整数型的序号级再其在容器中的位置，可以根据序号存取容器中的元素

J2SDK所提供的List容器类有ArrayList，LinkedList等

Object get(int index);
Object set(int index,Object lement);
void add(int index,Object element);
Object remove(int index);
int indexOf(Object o);
int lastIndexOf(Object o);

看一个例子：

public class Test{
    
    public static void main(String[] args) {
        
        LinkedList l1 = new LinkedList();
        for (int i=0; i<=5; i++) {
            l1.add("a" + i);
        }
        System.out.println(l1);//[a0, a1, a2, a3, a4, a5]
        l1.add(3,"a100");
        System.out.println(l1);//[a0, a1, a2, a100, a3, a4, a5]
        l1.set(6, "a200");
        System.out.println(l1);//[a0, a1, a2, a100, a3, a4, a200]
        System.out.println((String)l1.get(2)+ " ");//a2
        System.out.println(l1.indexOf("a3"));//4
        l1.remove(1);
        System.out.println(l1);//[a0, a2, a100, a3, a4, a200]
        
    }
}

List常用算法

void sort(List) //对list容器内的元素排序
void shuffle(List) //对list容器内的对象进行随机排列
void reverse(List) //岁list容器内的对象进行逆序排列
void fill(List,Object) //用一个特定的对象重写整个List容器
void copy(List dest,list src) //将srcList容器内容拷贝到destList容器
void binarySearch(List,Object) //对于顺序的list容器，采用着办查找的方法查找特定对象

看一个例子：

public class Test{
    
    public static void main(String[] args) {
        
        LinkedList l1 = new LinkedList();
                
        for(int i=0; i<=9; i++) {
            l1.add("a" + i);
        }
        
        System.out.println(l1);//[a0, a1, a2, a3, a4, a5, a6, a7, a8, a9]
        Collections.shuffle(l1);//随机排列
        System.out.println(l1);//[a9, a2, a7, a4, a1, a5, a3, a6, a8, a0]
        Collections.reverse(l1);//逆序
        System.out.println(l1);//[a0, a8, a6, a3, a5, a1, a4, a7, a2, a9]
        Collections.sort(l1);//排序
        System.out.println(l1);//[a0, a1, a2, a3, a4, a5, a6, a7, a8, a9]
        System.out.println(Collections.binarySearch(l1, "a5"));//折半查找,结果为5        
        
    }
}

2.Comparable接口

所有可以”排序”的类都实现了java.lang.Comparable接口，Comparable接口中只有一个方法：

public int compareTo(Object obj);

该方法：

• 返回0表示this == obj
• 返回正数表示this>obj
• 返回负数表示this <obj

实现了Comparable接口的类通过实现compataTo方法从而确定该类对象的排序方式

八、Map接口

实现Map接口的类用来存储键-值对

Map接口的实现类有HashMap和TreeMap等

Map类中存储的键-值对通过键来标识，所以键值不能重复

Object put(Object key,Object value);
Object get(Object key);
Object remove(Object key);
boolean containsKey(Object key);
boolean containsValue(Object value);
int size();
boolean isEmpty();
void putAll(Map t);
void clear();

看一个例子：

public class Test{
    
    public static void main(String[] args) {
        
        Map m1 = new HashMap();
        Map m2 = new TreeMap();
        
        m1.put("one", new Integer(1));
        m1.put("two", new Integer(2));
        m1.put("three", new Integer(3));
        
        m2.put("A", new Integer(1));
        m2.put("B", new Integer(2));
        
        System.out.println(m1.size());//3
        System.out.println(m1.containsKey("one"));//true
        System.out.println(m2.containsValue(new Integer(1)));//true
        
        if (m1.containsKey("two")) {
            int i = ((Integer)m1.get("two")).intValue();
            System.out.println(i);//2
        }
        
        Map m3 = new HashMap(m1);
        m3.putAll(m2);
        System.out.println(m3);//{A=1, B=2, two=2, three=3, one=1}
    }
}

九、自动打包/解包

在合适的时机自动打包、解包（JDK1.5之后的版本支持）

• 自动将基础类型转换为对象（打包）
• 自动将对象转换为基础类型（解包）

如此，上面的例子可以这么写：

public class Test{
    
    public static void main(String[] args) {
        
        Map m1 = new HashMap();
        Map m2 = new TreeMap();
        
        m1.put("one", 1);
        m1.put("two", 2);
        m1.put("three", 3);
        
        m2.put("A", 1);
        m2.put("B", 2);
        
        System.out.println(m1.size());//3
        System.out.println(m1.containsKey("one"));//true
        System.out.println(m2.containsValue(1));//true
        
        if (m1.containsKey("two")) {
            int i = ((Integer)m1.get("two"));
            System.out.println(i);//2
        }
        
        Map m3 = new HashMap(m1);
        m3.putAll(m2);
        System.out.println(m3);//{A=1, B=2, two=2, three=3, one=1}
    }
}

看一个练习例子：

/*
 * 注释掉的代码是使用了自动打包和解包进行的代码简化
 */
public class Test{
    
    private static final Integer ONE = new Integer(1);
    //private static final int ONE = 1;

    public static void main(String[] args) {
        
        Map m = new HashMap();
        
        for(int i=0; i<args.length; i++) {
            Integer freq = (Integer)m.get(args[i]);
            //int freq = (Integer)m.get(args[i]);
            m.put(args[i], (freq == null ? ONE : new Integer(freq.intValue() +1)));
            //m.put(args[i], freq==0 ? ONE : freq + 1);
        }
        
        System.out.println(m.size() + " distinct words detected: ");
        System.out.println(m);
        
    }
}

这是一个统计传外部参次数的例子

十、泛型（JDK1.5以后新增）

起因：

JDK1.4以前类型不明确：

• 装入集合的类型都被当作Object对待，从而时区自己的实际类型
• 从集合中取出时往往需要转型，效率低，容易产生错误

解决办法：

• 在定义集合的时候同事定义集合中对象的类型
• 可以在定义Collection的时候指定
• 也可以在循环时用Iterator指定

好处：

• 增强程序的可读性和稳定性

看一个例子：

public class Test{    
    public static void main(String[] args) {
        
        List<String> c = new ArrayList<String>();
        c.add("aaa");
        c.add("bbb");
        c.add("ccc");        
        for(int i=0; i<c.size(); i++) {
            String s = c.get(i);
            System.out.println(s);
        }
        
        
        Collection<String> c2 = new HashSet<String>();
        c2.add("aaa");
        c2.add("bbb");
        c2.add("ccc");        
        for(Iterator<String> it = c2.iterator(); it.hasNext();) {
            String s = it.next();
            System.out.println(s);
        }    
    }
}

在看一个例子：

public class Test{    
    public static void main(String[] args) {
        
        Map<String,Integer> m1 = new HashMap<String,Integer>();
        m1.put("one", 1);
        m1.put("two", 2);
        m1.put("three", 3);
        
        System.out.println(m1.size());
        System.out.println(m1.containsKey("one"));
        
        if(m1.containsKey("two")) {            
            int i = m1.get("two");
            System.out.println(i);
        }        
    }
}