Java学习笔记（八）：集合类

Java中对数据的存储会使用到集合类，下面我们来看看Java中常用的集合类。

Collection接口

集合的接口，可以简单的理解为可以动态扩充的数组。

Collection接口定义了很多相关的方法，基本上都是添加移除等管理元素相关的方法。

List接口

List接口是继承自Collection接口的子接口，其内部存放的元素对象是可以重复的。

下面我们来看两个比较常用的实现类：

ArrayList

JDK1.2推出，线程不安全类型，但执行效率高，在不涉及多线程的情况下使用：

import java.util.ArrayList;
import java.util.List;

public class Main
{
    public static void main(String[] args)
    {
        List<String> list = new ArrayList<String>();
        list.add("A");
        list.add("B");
        list.add("C");
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}

Vector

JDK1.0推出，线程安全，但执行效率较ArrayList低，在涉及多线程时使用：

import java.util.List;
import java.util.Vector;

public class Main
{
    public static void main(String[] args)
    {
        List<String> list = new Vector<String>();
        list.add("A");
        list.add("B");
        list.add("C");
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}

Set接口

Set接口是继承自Collection接口的子接口，其内部存放的元素对象是不可以重复的。

下面我们来看两个比较常用的实现类：

HashSet

散列存放数据，添加的数据是无序的；

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

public class Main
{
    public static void main(String[] args)
    {
        Set<String> set = new HashSet<String>();
        set.add("A");
        set.add("A");
        set.add("B");
        set.add("B");
        set.add("C");
        set.add("D");
        System.out.println(set);//[D, A, B, C]
    }
}

TreeSet

有序存放数据，无论添加的数据顺序如何，最终可以获取的数据都是按顺序存放的：

import java.util.Set;
import java.util.TreeSet;

public class Main
{
    public static void main(String[] args)
    {
        Set<String> set = new TreeSet<String>();
        set.add("A");
        set.add("A");
        set.add("B");
        set.add("B");
        set.add("C");
        set.add("D");
        System.out.println(set);//[A, B, C, D]
    }
}

Iterator接口

Java中的集合类都实现了Iterator接口，该接口实现了我们遍历集合中所有对象的方法，同时，迭代器也是23种设计模式中的一种，只不过Java中已经帮助我们实现了。

我们来看一个简单的例子：

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Main
{
    public static void main(String[] args)
    {
        List<String> list = new ArrayList<String>();
        list.add("A");
        list.add("B");
        list.add("C");
        //第一种循环方法
        Iterator<String> i = list.iterator();
        while(i.hasNext())
        {
            String str = i.next();
            //删除元素 B
            if(str.equals("B"))
            {
                i.remove();
            }
            System.out.println(str);
        }
        System.out.println("");
        //第二种循环方法
        for(Iterator<String> i2 = list.iterator(); i2.hasNext(); )
        {
            String str = i2.next();
            System.out.println(str);
        }
    }
}

使用迭代器：先通过集合的方法iterator获取该集合的迭代器，让后调用hasNext判断是否还有下一个元素，如果有则调用next获取下一个元素并将迭代器的指针指向后面的元素，如果想移除当前的元素，不要调用集合的remove方法，调用迭代器的remove即可安全移除集合中的当前元素。

for each

在JDK1.5中，Java添加了for each循环用来方便的遍历集合的所有元素，本质上for each也是一个迭代器，但是for each不允许在循环中移除集合的元素，如下：

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Main
{
    public static void main(String[] args)
    {
        List<String> list = new ArrayList<String>();
        list.add("A");
        list.add("B");
        list.add("C");
        //第一种循环方法
        Iterator<String> i = list.iterator();
        while(i.hasNext())
        {
            String str = i.next();
            System.out.println(str);
        }
        System.out.println("");
        //第二种循环方法
        for (String str : list) {
            System.out.println(str);
        }
    }
}

Map接口

Map使用键值对的方式来存储数据，我们主要来看看Map的两个实现类；

Hashtable

• Hashtable中的方法是同步的即线程安全，执行效率较HashMap会低一些。
• key和value都不允许出现null值。
• Hashtable直接使用对象的hashCode。
• Hashtable中hash数组默认大小是11，增加的方式是 old*2+1。

import java.util.Hashtable;
import java.util.Map;

public class Main
{
    public static void main(String[] args)
    {
        Map<Integer, String> map = new Hashtable<Integer, String>();
        map.put(1, "A");
        map.put(2, "B");
        map.put(3, "C");
        if(map.containsKey(1))
        {
            System.out.println(map.get(1));
            map.remove(1);
        }
        System.out.println(map.isEmpty());
    }
}

HashMap

• HashMap中的方法是异步的即线程不安全，执行效率较Hashtable快。
• 在HashMap中，null可以作为键，这样的键只有一个；可以有一个或多个键所对应的值为null。当get()方法返回null值时，即可以表示 HashMap中没有该键，也可以表示该键所对应的值为null。因此，在HashMap中不能由get()方法来判断HashMap中是否存在某个键， 而应该用containsKey()方法来判断。
• 而HashMap重新计算hash值。
• HashMap中hash数组的默认大小是16，而且一定是2的指数。

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

public class Main
{
    public static void main(String[] args)
    {
        Map<Integer, String> map = new HashMap<Integer, String>();
        map.put(1, "A");
        map.put(2, "B");
        map.put(3, "C");
        if(map.containsKey(1))
        {
            System.out.println(map.get(1));
            map.remove(1);
        }
        System.out.println(map.isEmpty());
    }
}

遍历Map

直接上代码：

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

public class Main
{
    public static void main(String[] args)
    {
        Map<Integer, String> map = new HashMap<Integer, String>();
        map.put(1, "A");
        map.put(2, "B");
        map.put(3, "C");
        //获取键和值
        for(Map.Entry<Integer, String> entry : map.entrySet())
        {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
        System.out.println("");
        //只获取键
        for(Integer key : map.keySet())
        {
            System.out.println(key);
        }
        System.out.println("");
        //只获取值
        for(String value : map.values())
        {
            System.out.println(value);
        }
        System.out.println("");
        //使用迭代器
        //在老版本java中这是惟一遍历map的方式。另一个好处是，你可以在遍历时调用iterator.remove()来删除entries，另两个方法则不能。
        Iterator<Map.Entry<Integer, String>> iterator = map.entrySet().iterator();
        while(iterator.hasNext())
        {
            Map.Entry<Integer, String> entry = iterator.next();
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
        System.out.println("");
        //通过键获取值，效率最低不建议使用
        for(Integer key : map.keySet())
        {
            String value = map.get(key);
            System.out.println(key + ": " + value);
        }
    }
}