【Java基础】集合 | 易学教程

一、Collection接口（超级接口:Iterator）

其下有两个子接口，Set和List。

1）Set接口的两个常用子类

TreeSet：有序存放

HashSet：散列存放

2）List接口（允许重复元素）

常用子类:LinkedList、ArrayList、Vector。ArrayList是List接口最常用的一个子类。LinkedList完成的是一个链表操作。

二、Map接口

实现子类：HashMap、HashTable、TreeMap等

TreeMap与TreeSet类似，TreeMap中元素根据key自动排序。

三、集合元素为自定义类时，集合的排序问题及 输出

自定义类作为集合元素时，集合本身不知道如何排序，必须类实现Comparable接口，并覆写compareTo()方法。

public class Person implements Comparable<Person> {
    private String name;
    private int age;
    public Person(String name, int age) {
        this.age = age;
        this.name = name;
    }
    @Override
    public int compareTo(Person o) {//按名字顺序排序
        return this.name.compareTo(o.name);
    }
    @Override
    public String toString() {
        return this.name + ":" + this.age;
    }
}
 
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.ListIterator;
public class Test001 {
    public static void main(String[] args) {
        ArrayList<Person> person = new ArrayList<Person>();
        person.add(new Person("何明", 20));
        person.add(new Person("小米", 22));
        person.add(new Person("Jane", 21));
        person.add(new Person("Katty", 20));
        person.add(new Person("Blue Key",20));
        person.add(new Person("乔布斯",20));
        Collections.sort(person);                        //排序
        Iterator<Person> ite=person.iterator();         //Iterator迭代
        while(ite.hasNext())
            System.out.println(ite.next());
        for(Person p:person)                           //foreach遍历
            System.out.println(p);
        System.out.println(person);          
        ListIterator<Person> lite= person.listIterator();//ListIterator迭代
        while(lite.hasNext())                         //从前往后遍历
        while(lite.hasPrevious())                     //从后向前比遍历，此操作需要从前往后遍历一趟
            System.out.println(lite.previous());
    } 
}
//输出结果：
//[Blue Key:20, Jane:21, Katty:20, 乔布斯:20, 何明:20, 小米:22]

import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
public class MapDemo {
    public static void main(String[] args) {
        Map<String, Integer> map = new TreeMap<>();   //按key排序
        map.put("诸葛亮", 3);
        map.put("孙悟空", 5);
        map.put("爱迪生", 8);
        map.put("孔乙己", 11);
        map.put("猪八戒", 7);
        Set<Map.Entry<String, Integer>> tree = map.entrySet();
        Iterator<Map.Entry<String, Integer>> ite = tree.iterator();
        while(ite.hasNext()) {
            Map.Entry<String,Integer> e=ite.next();
            System.out.println(e.getKey()+"-->"+e.getValue());
        }
        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            System.out.print(entry.getKey() + "-->" + entry.getValue()+" ");
       //孔乙己-->11 孙悟空-->5 爱迪生-->8 猪八戒-->7 诸葛亮-->3
        }
    }
}

四、Map的实现子类中，当键为自定义类时，要想通过一个匿名对象找到值，则需要覆写equals()、hashCode()方法区分是否同一个对象。

//构造一个Person类
public class Person implements Comparable<Person> {
    public Person(String name, int age) {
        this.age = age;
        this.name = name;
    }
    @Override
    public int compareTo(Person o) {
        return this.name.compareTo(o.name);
    }
    @Override
    public String toString() {
        return this.name + ":" + this.age;
    }
    @Override
    public boolean equals(Object obj) {//覆写equals()方法
        if (this == obj) {
            return true;
        } else if (!(obj instanceof Person)) {
            return false;
        }
        Person p = (Person) obj;
        if (this.name == p.name && this.age == p.age) {
            return true;
        } else {
            return false;
        }
    }
    @Override
    public int hashCode(){          //覆写hashCode()方法
        //公式：Person.hashcode=name.hashcode*age
        return this.name.hashCode()*this.age;      
    }
    private String name;
    private int age;
}
//测试代码
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
public class MapDemo01 {
    public static void main(String[] args) {
        Map<Person, String> map = new TreeMap<>();
        map.put(new Person("诸葛亮", 9), "zgl");
        map.put(new Person("孙悟空", 5), "swk");
        map.put(new Person("爱迪生", 8), "ads");
        map.put(new Person("孔乙己", 11), "kyj");
        map.put(new Person("猪八戒", 7), "zbj");
        /*
         * 通过一个Person类的匿名对象找到value值
         * 需要覆写Person类的hashCode()方法与equals()方法
         */
        System.out.println(map.get(new Person("诸葛亮", 9)));
        //输出TreeMap
        Set<Map.Entry< Person, String>> tree = map.entrySet();
        Iterator<Map.Entry< Person, String>> ite = tree.iterator();
        while (ite.hasNext()) {
            Map.Entry<Person, String> e = ite.next();
            System.out.println(e.getKey() + "-->" + e.getValue());
        }
        //foreach输出
        for (Map.Entry<Person, String> entry : map.entrySet()) {
            System.out.println(entry.getKey() + "-->" + entry.getValue());
        }
    }
}

五、总结

1、元素是否具有排序：只有树状的集合(比如TreeSet和TreeMap)才能对自定义的对象和自然元素进行排序，其他都没有排序。

2、元素的类型是否一致：只要具有排序的集合，里边元素的类型必须统一，而且不能为null值。(只有TreeSet和TreeMap里边的元素必须统一，其他集合都可以是任意的类型)

3、元素是否具有排重：只有Set和Map具有排重，List是没有排重的。

4、从数据是否安全：只有Vector和HashTable(Map的实现类)是线程安全的，其他都是不安全的。

来源：oschina

链接：https://my.oschina.net/u/922237/blog/102568

标签

collection