容器API

• JDK所提供的容器API位于java.util包内
• 容器API接口如下

接口

1. Collection接口
   : 定义了存取一组对象的方法，其子接口Set和List定义了存储方式。

   • Set中的数据对象没有顺序，且不可以重复
   • List中的数据对象有顺序可以重复

2. Map接口
   : 定义了存储“键——值”映射对的方法

Collection接口方法

1. 集合和元素之间操作的成员方法

boolean add(Object o) : 添加元素，确保词集合包含指定的元素，如果此集合随调用的结果发生改变，则返回true

boolean remove(Object o) : 从此集合中移除指定元素的单个实例，如果此集合随调用的结果发生改变，则返回true

void clear() : 移除此集合中的所以元素

int size() : 返回集合中的元素个数

boolean isEmpty() : 判断集合是否为空

boolean contains(Object obj) : 如果此集合不包含对象obj，返回true。本质：调用该对象的equal()方法判断

void sort() : 对集合进行排序（元素类实现Comparable接口）

2. 集合之间操作的成员方法

boolean addAll(Collection c) : 将指定collection中的所以元素都添加到此collection

boolean removeAll(Collection c) : 移除此集合中包含在c中的所以元素

boolean containsAll(Collection c) : 如果此collection中包含c中的所以元素，返回true 

Object[] toArray() : 返回包含此collection中所以元素的数组

Iteractor iteractor() : 返回此collection元素迭代后的迭代器

方法实例

• one（第一个自定义类Name中无toString()方法，而第二个有。解释两者输出的区别）

package 容器.collection接口;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;

class Name{
    private String name;
    Name(String name){
        this.name = name;
    }
}
public class test01 {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        c.add("hello");
        c.add(new Name("tangjiaping"));
        c.add(new Integer(11));

        System.out.println(c.size());
        System.out.println(c);
    }
}

结果：
3
[hello, 容器.collection接口.Name@6d6f6e28, 11]

package 容器.collection接口;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;

class Name{
    private String name;
    Name(String name){
        this.name = name;
    }

    @Override
    public String toString() {
        return this.name;
   }
}
public class test01 {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        c.add("hello");
        c.add(new Name("tangjiaping"));
        c.add(new Integer(11));

        System.out.println(c.size());
        System.out.println(c);
    }
}

结果：
3
[hello, tangjiaping, 11]

查看Collection的toString()方法

该toString()方法在父类AbstractList<E>的父类AbstractCollection中重写

public String toString() {
        Iterator var1 = this.iterator();
        if (!var1.hasNext()) {
            return "[]";
        } else {
            StringBuilder var2 = new StringBuilder();
            var2.append('[');

            while(true) {
                Object var3 = var1.next();
                var2.append(var3 == this ? "(this Collection)" : var3);
                if (!var1.hasNext()) {
                    return var2.append(']').toString();
                }

                var2.append(',').append(' ');
            }
        }
    }

查看Object的toString()方法

public String toString() {
        return this.getClass().getName() + "@" + Integer.toHexString(this.hashCode());
    }

解释

首先：利用System.out.println()默认调用该对象的toString()方法
由于String和Integer类系统默认重写了Object类中的toString()方法，所以输出结果没区别。
但是我们自己定义的Name类并没有重写toString()方法，所以运行系统会自动调用Object类中的toString()方法。第一次就是调用Object类中的toString()方法输出的结果
第二次输出，由于自己重写了toString()方法，所以输出结果就不一样。

• two（理解类中的equal()方法）

  • one code

package 容器.collection接口;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;

class Name{
    private String name;
    Name(String name){
        this.name = name;
    }

    @Override
    public String toString() {
        return this.name;
    }
}
public class test01 {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        
        c.add("hello");
        c.add(new Name("tangjiaping"));
        c.add(new Integer(11));
        System.out.println(c);
        
        System.out.println("----------------------------------");
        
        c.remove("hello");
        c.remove(new Integer(11));
        c.remove(new Name("tangjiaping"));
        System.out.println(c);
    }
}

结果：
[hello, tangjiaping, 11]
----------------------------------
[tangjiaping]

• • two code

package 容器.collection接口;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;

class Name{
    private String name;
    Name(String name){
        this.name = name;
    }

    @Override
    public String toString() {
        return this.name;
    }
}
public class test01 {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        Name name = new Name("zhangsan");

        c.add("hello");
        c.add(new Name("tangjiaping"));
        c.add(new Integer(11));
        c.add(name);
        System.out.println(c);

        System.out.println("----------------------------------");

        c.remove("hello");
        c.remove(new Integer(11));
        c.remove(new Name("tangjiaping"));
        c.remove(name);
        System.out.println(c);
    }
}

结果：
[hello, tangjiaping, 11, zhangsan]
----------------------------------
[tangjiaping]

• • there code(重写equals()方法)

package 容器.collection接口;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;

class Name{
    private String name;
    Name(String name){
        this.name = name;
    }

    @Override
    public String toString() {
        return this.name;
    }

    /**
    *重写equals()方法
    *这里判断属性值是否相等，由于属性为String类型，而String类型重写了equals()方法，所以可通过.属性.equals()判断。
    */
    @Override
    public boolean equals(Object o) {
        Name var = (Name)o;
        return this.name.equals(var.name);
    }
}
public class test01 {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        //Name name = new Name("zhangsan");

        c.add("hello");
        c.add(new Name("tangjiaping"));
        c.add(new Integer(11));
        //c.add(name);
        System.out.println(c);

        System.out.println("----------------------------------");

        c.remove("hello");
        c.remove(new Integer(11));
        c.remove(new Name("tangjiaping"));
        //c.remove(name);
        System.out.println(c);
    }
}

结果：
[hello, tangjiaping, 11]
----------------------------------
[]

Object类中的equals()方法

 public boolean equals(Object var1) {
        return this == var1;
    }

解释

前面两种代码Name类中都没有重写equals()方法，所以在删除元素时，系统调用Object对象中的equals()方法判断collection中的元素是否和传入的元素相等，相等就删除，不相等就不删除。
Object对象的equals()方法判断相等时，是判断两个对象的引用是否指向同一对象。
-----------------------------------------------------------------------------------
第一个代码：通过new的方式增加元素，然后通过new的方式删除元素，这两个元素并不是同一元素
第二个代码：通过name接受new出来的对象，然后在通过name引用增加和删除，显然是同一对象
第三个代码：Name类中重写的equals()元素，重写的方法认为两个对象的name属性值一样就是同一对象，由于字符串常量在内存中只存在一份，所以两者是一样的。

• 容器类对象在调用remove、contains等方法时需要比较对象是否相等，这会涉及对象类型的equals()和hashCode()方法
• 对于自定义的类型，需要重写equals()或hashCode()方法以实现自定义类型的对象的判断
• 注意：相等对象应该具有相同的hashCode码

Iterator接口

• 所以实现Collection接口的容器类都有一个Iteractor方法，用以返回一个实现了Iteractor接口的对象
• Iteractor对象称作为迭代器，用以方便的实现对容器类元素的遍历
• Iteractor接口定义了如下操作

boolean hasNext();   判断游标右边是否有元素
Object next();   返回游标右边的元素，并将游标移到下一个位置
void remove();   删除游标左面的元素，在执行完next之后该操作只能执行一次

package 容器.collection接口;


import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;

class Name_{
    private String name;
    Name_(String name){
        this.name = name;
    }

    @Override
    public String toString() {
        return this.name;
    }
}
public class test02 {
    public static void main(String[] args) {
        Collection c = new HashSet();
        c.add(new Name_("tang"));
        c.add(new Name_("zhangsan"));
        c.add(new Integer(11));
        c.add("fsdffs");
        
        /**
        *调用Collection接口的Iteractor（）方法，返回一个Iteractor对象
        */
        Iterator iterator = c.iterator();

        while (iterator.hasNext()){
            System.out.println(iterator.next());
             /**
             * java.lang.IllegalStateException
             * remove()方法一定要在next()方法后
             * 不然在第一个元素时，iterator.remove()删除为空
             * 会出现IllegalStateException异常
             */
            iterator.remove();  
            
            Object name = iterator.next();
             /**
             *  c.remove(name); 在运行时会报错
             */
             // c.remove(name);
        }
        System.out.println("----------------");
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

结果：
tang
zhangsan
11
fsdffs
----------------

Set接口

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

Set接口的方法，在判断相等时，会同时判断equals()和HashCode()方法

package 容器.set接口;

import java.util.HashSet;
import java.util.Set;

class Name{
    private String name;
    Name(String name){
        this.name = name;
    }
}
public class test01 {
    public static void main(String[] args) {
        Set set = new HashSet();

        System.out.println(set.add("tang"));
        /**
         * set中相同元素不会被加入，
         * 故set.add("tang")返回false
         */
        System.out.println(set.add("tang"));
        set.add("world");
        /**
         * Name类并没有重写equals()方法和HashCode()方法，所以都会被加入
         */
        System.out.println(set.add(new Name("dsfsf")));
        System.out.println(set.add(new Name("dsfsf")));

        System.out.println(set);
    }
}

结果：
true
false
true
true
[tang, world, 容器.set接口.Name@6d6f6e28, 容器.set接口.Name@135fbaa4]

package 容器.set接口;

import java.util.HashSet;
import java.util.Set;

class Name{
    private String name;
    Name(String name){
        this.name = name;
    }
    public boolean equals(Object o){
        if (o instanceof Name){
            Name var = (Name)o;
            return this.name.equals(var.name);
        }
        return super.equals(o);
    }

    @Override
    public int hashCode() {
        return this.name.hashCode();
    }
}
public class test01 {
    public static void main(String[] args) {
        Set set = new HashSet();

        System.out.println(set.add("tang"));
        /**
         * set中相同元素不会被加入，
         * 故set.add("tang")返回false
         */
        System.out.println(set.add("tang"));
        set.add("world");
        /**
         * Name类重写equals()方法和HashCode()方法，所以第二个不会被加入
         */
        System.out.println(set.add(new Name("dsfsf")));
        System.out.println(set.add(new Name("dsfsf")));

        System.out.println(set);
    }
}

结果：
true
false
true
false
[tang, world, 容器.set接口.Name@5b7024a]

List接口

• List接口是Collection的子接口，实现List接口的容器类中的元素时有序的，而且可以重复。
• List容器中的元素都对应一个整数型的下标记载其在容器中的位置，可以根据序号存取容器中的元素
• JDK提供的实现List接口的类有ArrayList、LinkedList等
• 定义如下方法

Object get(int index)

Object set(int index,Object o)

void add(int index,Object o)

Object remove(int index)

int indexOf(Object o)

int lastIndexOf(Object o)

package 容器.list接口;

import java.util.LinkedList;
import java.util.List;

public class test01 {
    public static void main(String[] args) {
        List list = new LinkedList();

        for (int i=0;i<5;i++){
                list.add("list" + i);
        }

        System.out.println(list);

        list.add(1,"fsdfsa");

        System.out.println(list);

        System.out.println(list.set(2,"foowero"));

        System.out.println(list.indexOf("list4"));

    }
}

结果：
[list0, list1, list2, list3, list4]
[list0, fsdfsa, list1, list2, list3, list4]
list1
5

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

package 容器.map接口;

import java.util.HashMap;
import java.util.Map;
import java.util.TreeMap;

public class test01 {
    public static void main(String[] args) {
        Map m1 = new HashMap();
        m1.put("one",new Integer(1));
        m1.put("two",new Integer(2));
        m1.put("three",new Integer(3));
        m1.put("four",new Integer(4));
        System.out.println(m1);
        /**
        *当键存在时，新放入的值会替代原有的值
        */
        m1.put("four",new Integer(5));
        System.out.println(m1);
        
        Map m2 = new TreeMap();
        m2.put("A",new Integer(1));
        m2.put("B",new Integer(2));

        System.out.println(m1.size());
        System.out.println(m1.containsKey("one"));

        System.out.println(m2.containsValue(new Integer(2)));

        if (m1.containsKey("two")){
            int i = ((Integer) m1.get("two")).intValue();
            System.out.println(i);
        }

        Map map3 = new HashMap(m1);
        map3.putAll(m2);
        System.out.println(map3);
    }
}

结果：
{four=4, one=1, two=2, three=3}
{four=5, one=1, two=2, three=3}
4
true
true
2
{A=1, B=2, two=2, three=3, four=5, one=1}