Java学习笔记(八):集合类 Collection接口 Iterator接口 Map接口

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

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

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

List接口

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

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

ArrayList

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

 1 import java.util.ArrayList;
 2 import java.util.List;
 3 
 4 public class Main
 5 {
 6     public static void main(String[] args)
 7     {
 8         List<String> list = new ArrayList<String>();
 9         list.add("A");
10         list.add("B");
11         list.add("C");
12         for (int i = 0; i < list.size(); i++) {
13             System.out.println(list.get(i));
14         }
15     }
16 }

Vector

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

 1 import java.util.List;
 2 import java.util.Vector;
 3 
 4 public class Main
 5 {
 6     public static void main(String[] args)
 7     {
 8         List<String> list = new Vector<String>();
 9         list.add("A");
10         list.add("B");
11         list.add("C");
12         for (int i = 0; i < list.size(); i++) {
13             System.out.println(list.get(i));
14         }
15     }
16 }

Set接口

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

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

HashSet

散列存放数据,添加的数据是无序的;

 1 import java.util.HashSet;
 2 import java.util.Set;
 3 
 4 public class Main
 5 {
 6     public static void main(String[] args)
 7     {
 8         Set<String> set = new HashSet<String>();
 9         set.add("A");
10         set.add("A");
11         set.add("B");
12         set.add("B");
13         set.add("C");
14         set.add("D");
15         System.out.println(set);//[D, A, B, C]
16     }
17 }

TreeSet

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

 1 import java.util.Set;
 2 import java.util.TreeSet;
 3 
 4 public class Main
 5 {
 6     public static void main(String[] args)
 7     {
 8         Set<String> set = new TreeSet<String>();
 9         set.add("A");
10         set.add("A");
11         set.add("B");
12         set.add("B");
13         set.add("C");
14         set.add("D");
15         System.out.println(set);//[A, B, C, D]
16     }
17 }

Iterator接口

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

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

 1 import java.util.ArrayList;
 2 import java.util.Iterator;
 3 import java.util.List;
 4 
 5 public class Main
 6 {
 7     public static void main(String[] args)
 8     {
 9         List<String> list = new ArrayList<String>();
10         list.add("A");
11         list.add("B");
12         list.add("C");
13         //第一种循环方法
14         Iterator<String> i = list.iterator();
15         while(i.hasNext())
16         {
17             String str = i.next();
18             //删除元素 B
19             if(str.equals("B"))
20             {
21                 i.remove();
22             }
23             System.out.println(str);
24         }
25         System.out.println("");
26         //第二种循环方法
27         for(Iterator<String> i2 = list.iterator(); i2.hasNext(); )
28         {
29             String str = i2.next();
30             System.out.println(str);
31         }
32     }
33 }

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

for each

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

 1 import java.util.ArrayList;
 2 import java.util.Iterator;
 3 import java.util.List;
 4 
 5 public class Main
 6 {
 7     public static void main(String[] args)
 8     {
 9         List<String> list = new ArrayList<String>();
10         list.add("A");
11         list.add("B");
12         list.add("C");
13         //第一种循环方法
14         Iterator<String> i = list.iterator();
15         while(i.hasNext())
16         {
17             String str = i.next();
18             System.out.println(str);
19         }
20         System.out.println("");
21         //第二种循环方法
22         for (String str : list) {
23             System.out.println(str);
24         }
25     }
26 }

Map接口

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

Hashtable

  • Hashtable中的方法是同步的即线程安全,执行效率较HashMap会低一些。
  • key和value都不允许出现null值。
  • Hashtable直接使用对象的hashCode。
  • Hashtable中hash数组默认大小是11,增加的方式是 old*2+1。
 1 import java.util.Hashtable;
 2 import java.util.Map;
 3 
 4 public class Main
 5 {
 6     public static void main(String[] args)
 7     {
 8         Map<Integer, String> map = new Hashtable<Integer, String>();
 9         map.put(1, "A");
10         map.put(2, "B");
11         map.put(3, "C");
12         if(map.containsKey(1))
13         {
14             System.out.println(map.get(1));
15             map.remove(1);
16         }
17         System.out.println(map.isEmpty());
18     }
19 }

HashMap

  • HashMap中的方法是异步的即线程不安全,执行效率较Hashtable快。
  • 在HashMap中,null可以作为键,这样的键只有一个;可以有一个或多个键所对应的值为null。当get()方法返回null值时,即可以表示 HashMap中没有该键,也可以表示该键所对应的值为null。因此,在HashMap中不能由get()方法来判断HashMap中是否存在某个键, 而应该用containsKey()方法来判断。
  • 而HashMap重新计算hash值。
  • HashMap中hash数组的默认大小是16,而且一定是2的指数。
 1 import java.util.HashMap;
 2 import java.util.Map;
 3 
 4 public class Main
 5 {
 6     public static void main(String[] args)
 7     {
 8         Map<Integer, String> map = new HashMap<Integer, String>();
 9         map.put(1, "A");
10         map.put(2, "B");
11         map.put(3, "C");
12         if(map.containsKey(1))
13         {
14             System.out.println(map.get(1));
15             map.remove(1);
16         }
17         System.out.println(map.isEmpty());
18     }
19 }

遍历Map

直接上代码:

 1 import java.util.HashMap;
 2 import java.util.Iterator;
 3 import java.util.Map;
 4 
 5 public class Main
 6 {
 7     public static void main(String[] args)
 8     {
 9         Map<Integer, String> map = new HashMap<Integer, String>();
10         map.put(1, "A");
11         map.put(2, "B");
12         map.put(3, "C");
13         //获取键和值
14         for(Map.Entry<Integer, String> entry : map.entrySet())
15         {
16             System.out.println(entry.getKey() + ": " + entry.getValue());
17         }
18         System.out.println("");
19         //只获取键
20         for(Integer key : map.keySet())
21         {
22             System.out.println(key);
23         }
24         System.out.println("");
25         //只获取值
26         for(String value : map.values())
27         {
28             System.out.println(value);
29         }
30         System.out.println("");
31         //使用迭代器
32         //在老版本java中这是惟一遍历map的方式。另一个好处是,你可以在遍历时调用iterator.remove()来删除entries,另两个方法则不能。
33         Iterator<Map.Entry<Integer, String>> iterator = map.entrySet().iterator();
34         while(iterator.hasNext())
35         {
36             Map.Entry<Integer, String> entry = iterator.next();
37             System.out.println(entry.getKey() + ": " + entry.getValue());
38         }
39         System.out.println("");
40         //通过键获取值,效率最低不建议使用
41         for(Integer key : map.keySet())
42         {
43             String value = map.get(key);
44             System.out.println(key + ": " + value);
45         }
46     }
47 }