Java——(二)Java集合容器

 

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流! -------

 一、基本概念

1)Collection:一个独立元素的序列,这些元素都服从一条或多条规则。List必须按照插入的顺序

保存元素,而Set不能有重复元素。Queue按照排队规则了确定对象产生的顺序(通常与它们被插

入的顺序相同)。

2)Map:一组成对的“键值对”对象,允许你使用键来查找值。ArrayList允许你使用数字来查找值

,因此在某种意义上讲,他讲数字与对象关联在了一起。映射表允许我们使用另一个对象来查找某

个对象,它也被称为“关联数组”,因为它将某些对象与另外一些对象关联在了一起;或者被称为“字

典”,因为你可以使用键对象来查找值对象,就像在字典中使用单词来定义一样。Map是强大的编程

工具。

Collection vs Collections

  首先,Collection 和 Collections 是两个不同的概念。之所以放在一起,是为了更好的比较。

Collection是容器层次结构中根接口。而Collections是一个提供一些处理容器类静态方法的类。

JDK不提供Collection接口的具体实现,而是提供了更加具体的子接口(如Set和List)实现。

 

那Collection接口存在有何作用呢?存在即是道理。

  原因在于:所有容器的实现类(如ArrayList实现了List接口,HashSet实现了Set接口)提供

了两个‘标准’的构造函数来实现:1、一个无参的构造方法(void)2、一个带有Collection类型单

参数构造方法,用于创建一个具有其参数相同元素新的Collection及其实现类等。实际上:因为所

有通用的容器类遵从Collection接口,用第二种构造方法是允许容器之间相互的复制。

 

二、Collection和Iterator接口

  Conllection接口概括了序列的概念——一种存放一组对象的方式。Collection接口里定义了如下

操作集合元素的方法。

  • boolean add(Object o):该方法把集合c里的所有元素添加到指定集合了i。如果集合对象被添加操

作改变了,则返回true。

  • boolean addAll(Collection c):该方法把集合c里的所有元素添加到指定集合里。如果集合对象被添

加操作改变了,则返回true。

  • void clear():清除集合里的所有元素,将集合长度变为0。
  • boolean contains(Object o):返回集合了是否包含指定元素。
  • boolean containsAll(Collection c):返回集合里是否包含集合c里的所有元素。
  • boolean isEmpty():返回集合是否为空。当集合长度为0时返回true,否则返回false。
  • Iterator iterator():返回一个Iterator对象,用于遍历集合里的元素。
  • boolean remove(Object o):删除集合中的指定元素o,当集合中包含了一个或多个元素o时,这些

元素将被删除,该反复将返回true。

  • boolean removeAll(Collection c):从集合中删除集合c里包含的所有元素(相当于调用该方法的集

合减集合c),如果删除了一个或多个以上的元素,则该方法返回true。

  • boolean retainAll(Collection c):从集合中删除集合c里不包含的元素(相当于用调用该方法的集

合变成该集合和集合c的交集),如果该操作改变了调用该方法的集合,则该方法返回true。

  • int size():该方法返回集合里元素的个数。
  • Object[] toArray():该方法把集合转换成一个数组,所有的集合元素变成对应的数组元素。

 

下面程序将示范如何通过上面的方法来操作Collection集合里的元素

 1 import java.util.ArrayList;
 2 import java.util.Collection;
 3 import java.util.HashSet;
 4 
 5 public class CollectionTest {
 6 
 7     public static void main(String[] args) {
 8         Collection collection = new ArrayList();
 9         // 添加元素
10         collection.add("暨雪");
11         // 虽然集合里不能放基本类型的值,但Java支持自动装箱
12         collection.add(21);
13         System.out.println("collection集合的元素个数为:" + collection.size());
14         // 删除指定元素
15         collection.remove(21);
16         System.out.println("collection集合的元素个数为:" + collection.size());
17         // 判断是否包含指定字符串
18         System.out.println("Collection集合是否包含\"暨雪\"字符串"
19                 + collection.contains("暨雪"));
20         collection.add(18);
21         System.out.println("collection集合的元素个数为:" + collection.size());
22 
23         Collection action = new HashSet<>();
24         action.add(18);
25         action.add('x');
26         System.out.println("collection是否完全包含action集合?"
27                 + collection.containsAll(action));
28         //用Collection集合减去action集合里的元素
29         collection.removeAll(action);
30         System.out.println("collection集合的元素个数为:" + collection.size());
31         //删除Collection集合里的所有元素
32         collection.clear();
33         System.out.println("collection集合的元素个数为:" + collection.size());
34         //action集合里只剩下Collection集合里也包含的元素
35         action.retainAll(collection);
36         System.out.println("action集合的元素:" + action);
37     }
38 
39 }

 运行结果:

collection集合的元素个数为:2
collection集合的元素个数为:1
Collection集合是否包含"暨雪"字符串true
collection集合的元素个数为:2
collection是否完全包含action集合?false
collection集合的元素个数为:1
collection集合的元素个数为:0
action集合的元素:[]

  上面程序中创建了两个Collection对象,一个是collection集合,一个是action集合,其中

collection集合是ArrayList,二action集合是HashSet。虽然它们使用的实现类不同,但当把

它们当成Collection来使用时,使用add、remove、clear等方法来操作集合时没有任何区别。

 

三、使用Iterator接口遍历集合元素

  Iterator接口也是Java集合框架的成员,但它与Collection系列、Map系列的集合不一样

:Collection系列集合、Map系列集合主要用于盛装其他对象,而Iterator则主要用于遍历(

即迭代访问)Collection集合中的元素,Iterator对象也被称为迭代器。

  Iterator接口隐藏了各种Collection实现类的底层细节,向应用程序提供了遍历Collection

集合元素的统一编程接口。Iterator接口了定义如下三个方法:

  • boolean hasNext():如果被迭代的集合元素还没有被遍历,则返回true。
  • Object next():返回集合里的下一个元素。
  • void remove():删除集合了上一次next方法返回的元素。

  下面程序示范了通过Iterator接口来遍历集合元素。

 1 import java.util.Collection;
 2 import java.util.HashSet;
 3 import java.util.Iterator;
 4 
 5 public class IteratorTest {
 6 
 7     public static void main(String[] args) {
 8         // 创建一个集合
 9         Collection name = new HashSet<>();
10         name.add("张三");
11         name.add("李四");
12         name.add("王五");
13         // 获取name集合对应的迭代器
14         Iterator it = name.iterator();
15         while (it.hasNext()) {
16             // it.next()方法返回的数据类型是Object类型
17             // 需要强制类型转换
18             String names = (String) it.next();
19             System.out.println(names);
20             if (names.equals("李四")) {
21                 // 从集合中删除上一次next方法返回的元素
22                 it.remove();
23             }
24             // 对names变量赋值,不会改变集合元素本身
25             names = "测试字符串";
26         }
27         System.out.println(name);
28     }
29 
30 }

运行结果:

张三
李四
王五
[张三, 王五]

从上面代码中可以看出,Iterator仅用于遍历集合,Iterator本身并不提供盛装对象的能力。如

果需要参加Iterator对象,则必须有一个被迭代的集合。没有集合的Iterator仿佛无本之木,没

有存在的价值。

注意:

Iterator必须依附于Collection对象,若有一个Iterator对象,则必然有一个与之关联的

Collection对象。Iterator提供了两个仿佛来迭代访问Collection集合里的元素,并可以通过

remove()方法来删除集合中上一次next()方法返回的集合元素。

四、容器的打印

对TreeSet,HashSet,LinkedList,ArrayList,TreeMap,HashMap的例子如下:

 

 1 import java.util.*;
 2 
 3 public class CollectionAll
 4 {
 5 
 6     public static void main(String[] args)
 7     {
 8         printLists();
 9 
10         printSets();
11 
12         printMaps();
13     }
14 
15     private static void printLists()
16     {
17         List<String> a1 = new ArrayList<String>();
18         a1.add("List");
19         a1.add("Set");
20         a1.add("Queue");
21         a1.add("Map");
22         a1.add("List");
23         System.out.println("ArrayList Elements:");
24         System.out.println("    " + a1);
25 
26         List<String> l1 = new LinkedList<String>();
27         l1.add("List");
28         l1.add("Set");
29         l1.add("Queue");
30         l1.add("Map");
31         l1.add("List");
32         System.out.println("LinkedList Elements:");
33         System.out.println("    " + l1);
34     }
35     private static void printSets()
36     {
37         Set<String> h1 = new HashSet<String>();
38         h1.add("List");
39         h1.add("Set");
40         h1.add("Queue");
41         h1.add("Map");
42         h1.add("List");
43         System.out.println("HashSet Elements:");
44         System.out.println("    " + h1);
45 
46         Set<String> t1 = new TreeSet<String>();
47         t1.add("List");
48         t1.add("Set");
49         t1.add("Queue");
50         t1.add("Map");
51         t1.add("List");
52         System.out.println("TreeSet Elements:");
53         System.out.println("    " + t1);
54     }
55 
56     private static void printMaps()
57     {
58         Map<String, String> h1 = new HashMap<String, String>();
59         h1.put("List", "ArrayList");
60         h1.put("Set", "HashSet");
61         h1.put("Queue", "PriorityQueue");
62         h1.put("Map", "HashMap");
63         h1.put("List", "ArrayList");
64         System.out.println("HashMap Elements:");
65         System.out.println("    " + h1);
66 
67         Map<String, String> t1 = new TreeMap<String,String>();
68         t1.put("List", "ArrayList");
69         t1.put("Set", "HashSet");
70         t1.put("Queue", "PriorityQueue");
71         t1.put("Map", "HashMap");
72         t1.put("List", "ArrayList");
73         System.out.println("TreeMap Elements:");
74         System.out.println("    " + t1);
75 
76     }
77 }

 

运行结果:

ArrayList Elements:
    [List, Set, Queue, Map, List]
LinkedList Elements:
    [List, Set, Queue, Map, List]
HashSet Elements:
    [Map, Queue, Set, List]
TreeSet Elements:
    [List, Map, Queue, Set]
HashMap Elements:
    {Map=HashMap, Queue=PriorityQueue, Set=HashSet, List=ArrayList}
TreeMap Elements:
    {List=ArrayList, Map=HashMap, Queue=PriorityQueue, Set=HashSet}

 

  这里展示了Java容器类库中的两种主要类型,它们的区别在于容器中每个“槽”保存的元素个

数。Collection在每个槽中只能保存一个元素。此类容器包含:

List:它以特定的顺序保存一组元素;

Set:元素不能重复;

Queue:值允许在容器的一“端”插入对象,并从另外一“端”移除对象。Map在每个槽内保存了两

个对象,即键和与之相关的值。

  从打印结果来看,ArrayList和LinkedList都是List类型,它们都按照被插入的顺序保存元素

。两者的不同之处不仅在于执行某些类型的操作时的性能,而且LinkedList包含的操作也多于

ArrayList。

  HashSet、TreeSet和LinkedHashSet都是Set类型,每个相同的项只有保存一次,但输出

也显示了不同的Set实现存储元素的方式也不同。HashSet使用的是相当复杂的方式来存储元素

的,因此,存储的顺序看起来并无实际意义。如果存储顺序很重要,那么可以使用TreeSet,它

按照比较结果的升序保存对象;或者使用LinkedHashSet,它按照被添加的顺序保存对象。

  本例使用了三种基本风格的Map:HashMap、TreeMap和LinkedHashSet。与HashSet一

样,HashMap也提供了最快的查找技术,也没有按照任何明显的顺序来曹操其元素。TreeMap

按照比较结果的升序保存键,而LinkedHashMap则按照插入顺序保存键,同时还保留了HashMap

的查询速度。

 

posted @ 2015-06-08 18:15  DyncKathline  阅读(201)  评论(0编辑  收藏  举报