Java集合之Collection接口

集合概述

Java集合类是一种类似于数组的，存储对象引用（而非对象本身）的容器。集合石存储对象最常用的一种方式。集合中可以存储任意类型的对象，且长度可变，这就是说它类似于数组却又不同于数组的原因，集合比数组更加适用。集合可以使用对象的增、删、改、查等操作。

集合框架图

图中，实现边框的是实现类，如ArrayList、LinkedList、HashMap等；短线边框的是抽象类，如AbstractCollection、AbstractList、AbstractMap等；点线边框的是接口，如Iterator、Collection、Map等。
由框架图可知，存在多种集合容器，每一种集合容器对数据的存储方式都各不相同。基本的特点如下所示：

---|Collection: 单列集合
           ---|List: 有存储顺序, 可重复
              ---|ArrayList:    数组实现, 查找快, 增删慢
                          由于是数组实现, 在增和删的时候会牵扯到数组
                          增容, 以及拷贝元素. 所以慢。数组是可以直接
                          按索引查找, 所以查找时较快
              ---|LinkedList:   链表实现, 增删快, 查找慢
                          由于链表实现, 增加时只要让前一个元素记住自
                          己就可以, 删除时让前一个元素记住后一个元
                          素, 后一个元素记住前一个元素. 这样的增删效
                          率较高但查询时需要一个一个的遍历, 所以效率
                          较低
              ---|Vector:   和ArrayList原理相同, 但线程安全, 效率略低
                            和ArrayList实现方式相同, 但考虑了线程安全问
                            题, 所以效率略低
           ---|Set: 无存储顺序, 不可重复
              ---|HashSet
              ---|TreeSet
              ---|LinkedHashSet
---| Map: 键值对
       ---|HashMap
       ---|TreeMap
       ---|HashTable
       ---|LinkedHashMap    

对于不同的需求，我们可以选择适当的集合容器，来获取最大的效益。

集合类Collection

查看Collection类的API文档可以发现，其存在多个子接口，常用的有List和Set两种。
——-| Collection 单例集合的跟接口。
———-| List 如果是实现了List接口的集合类，具备的特点： 有序，可重复。
———-| Set 如果是实现了Set接口的集合类，具备特点： 无序，不可重复。

Collection接口中实现的方法主要有一下5种：
- 1.增加
add(E e) 添加成功返回true，添加 失败返回false.
addAll(Collection c) 把一个集合 的元素添加到另外一个集合中去。
- 2.删除
clear() 清空集合
remove(Object o) 移除集合中指定的元素
removeAll(Collection c)
retainAll(Collection c)
- 3.查看
size() 返回集合元素的个数
- 4.判断
isEmpty() 判断集合是否为空
contains(Object o) 判断集合中是否包含指定元素
containsAll(Collection

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
public class demo1 {
    public static void main(String[] args) {
        // 创建集合对象
        Collection coll = new ArrayList();
        // 创建Person对象
        Person p1 = new Person("jack", 25);
        Person p2 = new Person("rose", 22);
        Person p3 = new Person("lucy", 20);
        Person p4 = new Person("jack", 25);
        // 集合中添加一些Perosn
        coll.add(p1);
        coll.add(p2);
        // 删除指定Person
        //coll.remove(p1);
        System.out.println("coll "+coll);
        // 删除所有Person
        coll.removeAll(coll);
        // 判断容器中是否还有Person
        //System.out.println("coll "+coll);
        // 判断容器中是否包含指定Person
        coll.add(p4);
        coll.add(p3);
        //contains方法内部默认调用的是equals方法比较（equals默认比较的是对象的内存地址），此处必然会
        //返回false
        System.out.println("contains "+coll.contains(new Person("jack",25)));
        // 获取容器中Person的个数
        System.out.println("collection has "+coll.size()+" person");
        Object[] a = null;
        // 将容器变为数组,遍历除所有Person
        a = coll.toArray();
        System.out.println(Arrays.toString(a));
    }
}
class Person {
    private String name;
    private int age;

    public Person() {
    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public int hashCode() {
        return this.name.hashCode() + age;
    }
    @Override
    public boolean equals(Object obj) {
        // TODO Auto-generated method stub
        Person pp = (Person) obj;
        return this.name == pp.name;
    }
/*
    @Override
    public boolean equals(Object obj) {
        if (!(obj instanceof Person)) {
            return false;
        }
        Person p = (Person) obj;
        return this.name.equals(p.name) && this.age == p.age;
    }*/
    @Override  
    public String toString() {
        return "Person :name=" + name + ", age=" + age;
    }
}

java规范中指定重写equals()方法后，也要重写hashcode()方法。
toString方法

public String toString()
   返回该对象的字符串表示。通常，toString 方法会返回一个“以文本方式表示”此对象的字符串。结果应是一个简明但易于读懂的信息表达式。建议所有子类都重写此方法。
       Object 类的 toString 方法返回一个字符串，该字符串由类名（对象是该类的一个实例）、at 标记符“@”和此对象哈希码的无符号十六进制表示组成。换句话说，该方法返回一个字符串，它的值等于：
               getClass().getName() + '@' + Integer.toHexString(hashCode())
返回：
       该对象的字符串表示形式。

迭代器的使用

迭代器可以实现对collection进行迭代，即就是可以便利集合中的所有元素。
迭代器的实现的方法有下边三种：
- 1.hasNext() 问是否有元素可遍历。如果有元素可以遍历，返回true，否则返回false 。
- 2.next() 获取元素
- 3.remove() 移除迭代器最后一次返回的元素。
如果事先没有使用hasNext()方法进行判断是否有元素可遍历，可能会出现NoSuchElementException异常，原因是没有元素可以被迭代了。

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class demo1 {
    public static void main(String[] args) {
        Collection aa = new ArrayList();
        aa.add("张三");
        aa.add("李四");
        aa.add("王五");
        aa.add("马六");

        Iterator it = aa.iterator();      //返回一个迭代器，为一个接口类型
        while(it.hasNext()) {
            System.out.println(it.next());
        }
        it.remove();  //从迭代器指向的 collection 中移除迭代器返回的最后一个元素
        System.out.println(aa);
    }
}

Iterator it = aa.iterator()，iterator()方法返回的是一个接口类型，为什么接口又可以调用方法可以使用呢？ 实际上这块使用了多态，iterator 上返回的是iterator接口的实现类对象。

多态的实例

interface Money{
    public void makeMoney();
}
class Worker implements Money{
    @Override
    public void makeMoney() {
        // TODO Auto-generated method stub
        System.out.println("工人在赚钱。。。");
    }
}
public class demo {
    public static void main(String[] args) {
        Money mon = test();   //此处test()方法返回值为Money接口类型，但是这个方法的具体实现实实在在return返回的是其实现类的对象
        mon.makeMoney();
    }
    //此处使用了多态，若直接将test方法的返回值写死（即Worker类型）也可以，
    //但是这样会造成代码的不灵活，若还有一个Student类实现了Money接口，写死就不能返回Student类了
    public static Money test(){
        return new Worker();
    }
}