java基础12：集合

 一、概述

对象用于封装特有数据，对象多了需要存储，如果对象的个数不确定。就使用集合容器进行存储。

java集合类主要负责保存、盛装其他数据，因此集合类也称容器类。java集合类分为：set、list、map三大体系。

其中set代表无序、不可重复的集合；

------list代表有序、可重复的集合。

-----map代表具有映射关系的集合。

java中集合特点：

1，用于存储对象的容器。

2，集合的长度是可变的。

3，集合中不可以存储基本数据类型值。 

list是有序集合，list元素允许重复，实现list有两种形式，ArrayList，linkedList

ArrayList查询比较快，linkesList增加比较快，开发过程中常用的是ArrayList。

 

set是一个无序集合，它的元素不允许重复，它的实现形式有两种，HashSet与TreeSet

HashSet中的数据是无序的，TreeSet的元素是可以排序的，

 

map 是一个以键值对存在，k不可以重复，它的实现形式有两种，常见的实现形式有hasemap与hasetable

hasemap允许一个key或多个value为空，hasetable不允许空的键(k)或值(v)

 二、集合框架

集合框架由来：

集合容器因为内部的数据结构不同，有多种具体容器。

不断的向上抽取，就形成了集合框架。

这部分的知识还是比较多的，如果以前没接触过看文字叙述肯定把你看懵了，先看一下总体的框架图

java集合类主要由两个接口派生：Collection和Map，是集合框架的根接口。我们首先来介绍一下Collection接口

 三、Collection接口

1、概述

Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素。一些 Collection允许相同的元素而另一些不行。一些能排序而另一些不行。

由Collection接口派生的两个接口是List和Set。

2、迭代

关于Collection的常见操作就不说了，大家查一下API文档就会很清楚，这里重点说一下迭代。

如何遍历Collection中的每一个元素？根据上面的集合框架图我们可以看出，不论Collection的实际类型如何，它都支持一个iterator()的方法，该方

法返回一个迭代子，使用该迭代子即可逐一访问Collection中每一个元素。

举例：

[java] view plain copy

1. <span style="font-size:14px;">    <pre name="code" class="java">    Collection<String> c = new ArrayList<String>();//定义一个集合c  
2.         Collection<String> c1 = new ArrayList<String>();//定义一个集合c1  
3.         c.add("jin");//添加元素  
4.         c.add("fulin");  
5.         c1.add("uuu");  
6.         c1.add("fff");  
7.         c.addAll(c1);//将c1添加到c中  
8.         Iterator<String> it = c.iterator();//定义一个迭代器it  
9.         while(it.hasNext())//是否读取到下一个元素？为真则打印     
10.         System.out.println(it.next());</span>  

 四、List

1、概述

List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引（元素在List中的位置，类似于数组下标）来访问List中的元素，这类似于Java的数组。

它包括三个子类ArrayList、LinkList、Vector，关于它们的关系，如下图

2、ListIterator接口

在迭代时，不可以通过集合对象的方法操作集合中的元素。

如果想要添加、修改操作，就需要使用其子接口：ListIterrator。

注意：只有list集合具备该迭代功能.

举例：

[java] view plain copy

1. <span style="font-size:14px;">        List<String> list = new ArrayList<String>();  
2.         list.add("jin");  
3.         list.add("fulin");  
4.         ListIterator<String> it = list.listIterator();  
5.         System.out.println(list);  
6.         while(it.hasNext())   
7.         {  
8.             Object obj = it.next();  
9.             if (obj == "jin") {  
10.                 it.set("bbb");  //注意是it的修改和添加，而不是list  
11.                 it.add("aaa");    
12.             }  
13.               
14.         }  
15.         System.out.println(list);  
16.     }</span>
    

   

List中的set方法和add方法

 

public class TestList { public static void main(String[] args){    List l1 = new LinkedList();    for(int i=0; i<=5; i++){     l1.add("a"+i);    }    System.out.println(l1);    l1.add(3,"a100");    System.out.println(l1);    String b = (String)l1.set(3, "a200");    System.out.println(b);    System.out.println(l1);       } } --------- 结果: [a0, a1, a2, a3, a4, a5] [a0, a1, a2, a100, a3, a4, a5] a100 [a0, a1, a2, a200, a3, a4, a5] ============================================================== add方法是在某个指定的位置加上某个对象,并将原来的位置的那个对象向后挤了一格. set方法是将原来位置上的那个给取代了,并将原来位置上对象的返回.

 五、Set

1、概述

Set是一种不包含重复的元素的Collection，它包括两种类，一个是HashSet、一个是TreeSet、对应着数据结构中的哈希表哈希表和数结构。

2、HashSet

HashSet: 内部数据结构是哈希表 ，是不同步的。

A、如何保证该集合的元素唯一性呢？

是通过对象的hashCode和equals方法来完成对象唯一性的。‘

B、哈希表如何判断元素相同?

1、判断hashCode是否相同？

2、若为ture，判断equals是否相同？

3、若还为ture，视为相同元素不存。

所以：如果元素要存储到HashSet集合中，必须覆盖hashCode方法和equals方法。

[java]

1. <span style="font-size:14px;"><pre name="code" class="java">package cn.jinfulin.P.bean;  
2.   
3. 
   
4. public class Person  implements Comparable<Person>{//继承Comparable接口  
5.     private String name;  
6.     private int age;  
7.     public String getName() {  
8.         return name;  
9.     }  
10.   
11.     public void setName(String name) {  
12.         this.name = name;  
13.     }  
14.   
15.     public int getAge() {  
16.         return age;  
17.     }  
18.   
19.     public void setAge(int age) {  
20.         this.age = age;  
21.     }  
22.   
23.     public Person(String name, int age) {  
24.         super();  
25.         this.name = name;  
26.         this.age = age;  
27.     }  
28.     public Person(){}  
29.   
30.     public int hashCode() {<span style="white-space:pre"> </span>//复写hashCode编码，这里用的是自动生成的，可以自定义。  
31.         final int prime = 31;  
32.         int result = 1;  
33.         result = prime * result + age;  
34.         result = prime * result + ((name == null) ? 0 : name.hashCode());  
35.         return result;  
36.     }  
37.   
38.       
39.     public boolean equals(Object obj) {//复写equals方法，如果hashCode相同才判断  
40.         if (this == obj)  
41.             return true;  
42.         if (obj == null)  
43.             return false;  
44.         if (getClass() != obj.getClass())  
45.             return false;  
46.         Person other = (Person) obj;  
47.         if (age != other.age)  
48.             return false;  
49.         if (name == null) {  
50.             if (other.name != null)  
51.                 return false;  
52.         } else if (!name.equals(other.name))  
53.             return false;  
54.         return true;  
55.     }  
56. }</span>  

调用：

[java]

1. <span style="font-size:14px;">    private static void myHashCodeDemo() {  
2.         HashSet<Person> hs = new HashSet<Person>();  
3.         hs.add(new Person("jin",12));  
4.         hs.add(new Person("fu",22));  
5.         hs.add(new Person("fu",12));  
6.         hs.add(new Person("lin",15));  
7.           
8. /*      for (Person p : hs) {//for循环的另一种形式，和下面的迭代器循环表达一个意思。 
9.             System.out.println(p.getName()+":" + p.getAge()); 
10.         }*/  
11.           
12.         Iterator<Person> it = hs.iterator();  
13.         while(it.hasNext())  
14.         {  
15.             Person p  = it.next();  
16.             System.out.println(p.getName()+":" + p.getAge());  
17.         }  
18.           
19.     }</span>  

3、TreeSet

TreeSet:可以对Set集合中的元素进行排序。是不同步的。 

判断元素唯一性的方式：

就是根据compareTo()或compare()方法的返回结果是否是0，是0，就是相同元素，不存。 

TreeSet对元素进行排序的方式一：

1、让元素自身具备比较功能，就需要实现Comparable接口。覆盖compareTo方法。

2、让集合自身具备比较功能，定义一个类实现Comparator接口，覆盖compare方法。将该类对象作为参数传递给TreeSet集合的构造函数。

[java]

1. <span style="font-size:14px;"><pre name="code" class="java">//方法一  
2. public class Person implements Comparable<Person>{//实现Cmopareable接口，定义泛型为Person  
3.     private String name;  
4.     private int age;  
5.   
6.     public String getName() {  
7.         return name;  
8.     }  
9.   
10.     public void setName(String name) {  
11.         this.name = name;  
12.     }  
13.   
14.     public int getAge() {  
15.         return age;  
16.     }  
17.   
18.     public void setAge(int age) {  
19.         this.age = age;  
20.     }  
21.     /**构造函数 
22.      * @param name 
23.      * @param age 
24.      */  
25.     public Person(String name, int age) {  
26.         super();  
27.         this.name = name;  
28.         this.age = age;  
29.     }  
30.     public Person(){  
31.     }  
32.   
33.     public int compareTo(Person p) {//覆写compareTo方法，因为添加泛型，所有传参可以为Person类型  
34. //      Person p = (Person) o;  
35.         int temp = this.age - p.age;  
36.         return temp == 0?this.name.compareTo(p.name):temp;  
37.     }</span>  

调用

[java]

1. <span style="font-size:14px;">    private static void myTreeSetDemo() {  
2.         TreeSet<Person> ts = new TreeSet<Person>();  
3.         ts.add(new Person("jin",12));  
4.         ts.add(new Person("fu",22));  
5.         ts.add(new Person("fu",22));  
6.         ts.add(new Person("lin",15));  
7.         for (Person p : ts) {  
8.             System.out.println(p.getName()+":" + p.getAge());  
9.         }  
10.     }</span>  

[java]

1. <span style="font-size:14px;"><pre name="code" class="java">//方法二：    
2. public int compare(Person o1, Person o2) {  
3.         int result = o1.getName().compareTo(o2.getName());  
4.         return result == 0 ? o1.getAge()-o2.getAge():result;  
5.     /*等同于上面的语句 
6.     if (result == 0) { 
7.             if(o1.getAge() - o2.getAge()==0) 
8.             { 
9.                 return 0; 
10.             } 
11.         } 
12.         return result; 
13. */  
14.           
15.     }</span>  

调用

[java]

1. <span style="font-size:14px;">    private static void myTreeSetDemo2() {  
2.         TreeSet<Person> ts = new TreeSet<Person>(new CompareByName());  
3.         ts.add(new Person("jin",12));  
4.         ts.add(new Person("fu",22));  
5.         ts.add(new Person("fu",22));  
6.         ts.add(new Person("lin",15));  
7.         for (Person p : ts) {  
8.             System.out.println(p.getName()+":" + p.getAge());  
9.         }  
10.     }</span>  

 六、Map

1、概述

  Map<K,V>集合是一个接口，和List集合及Set集合不同的是，它是双列集合，并且可以给对象加上名字，即(键)。

其实map集合中存储的就是键值对。 

map集合中必须保证键的唯一性。 

2、Map与Collection区别

Map：一次添加一对元素。Collection 一次添加一个元素。

Map也称为双列集合，Collection集合称为单列集合。

3、常用方法举例：

[java]

1. <pre name="code" class="java"><pre name="code" class="java"><span style="font-size:14px;">public static void main(String[] args) {  
2.         Map<Integer, String> m = new HashMap<Integer, String>();// 初始化  
3.         m.put(1, "jin");  
4.         m.put(2, "fu");  
5.         m.put(3, "lin");  
6.         m.put(4, "aaa");  
7.         // m.clear(); //清空Map  
8.         // Set<Entry<Integer, String>> sm = m.entrySet(); //读取map的一种方式  
9.         Set<Integer> sm = m.keySet();// 读取map的第二种方式  
10.         Iterator<Integer> it = sm.iterator();  
11.         while (it.hasNext()) {  
12.             Integer key = it.next();  
13.             String value = m.get(key);  
14.             System.out.println("键:" + key + "," + "值:" + value);  
15.         }  
16.         // System.out.println(m.get(1)); //get方法通过键获取值  
17.     }</span>  

4、Map常用的子类：

|--Hashtable :内部结构是哈希表，是同步的。不允许null作为键，null作为值。
|--Properties：用来存储键值对型的配置文件的信息，可以和IO技术相结合。
|--HashMap : 内部结构是哈希表，不是同步的。允许null作为键，null作为值。
|--TreeMap : 内部结构是二叉树，不是同步的。可以对Map集合中的键进行排序。 

 七、最后

本章内容比较多，感谢能看到这里的朋友，要想学好，还需要大家对照图，多整理，多思考，勤复习。