规则框架java 规则框架结构

知识点

Java集合框架支持规则集、线性表、队列和图，他们分别定义在接口Set、List、Quene和Map中。

规则集用于存储一组互不相同的元素。

线性表用于存储一个有序的元素集合。

图（Map）中存储的是键/值对。

Java集合框架中的所有实例类都实现了Cloneable和Serializable接口。所以，它们的实例都是可以复制和可序列化的。

规则集存储的是不重复的元素。若要在集合中存储重复的元素，就需要使用线性表。线性表不仅可以存储重复的元素，而且允许用户指定存储的位置。用户可以通过下标来访问线性表中的元素。

Java集合框架支持三种类型的规则集：散列集HashSet、链式散列集LinkedHashSet和树型集TreeSet。HashSet以一个不可预知的顺序存储元素；LinkedHashSet以元素被插入的顺序存储元素；TreeSet存储已排好的元素。所有方法都继承自Collection接口。

Java集合框架支持两种类型的线性表：数组线性表ArrayList和链表LinkedList。ArrayList是实现List接口的可变大小的数组。ArrayList中的所有方法都是在List接口中定义的。LinkedList是实现List接口的一个链表。除了实现List接口，该类还提供了可从线性表两端提取、插入以及删除元素的方法。

Vector类实现了List接口。Vector类和ArrayList是一样的，所不同的是它所包含的访问和修改向量的方法是同步的。Stack类扩展了Vector类，并且提供了几种对栈进行操作的方法。

Queue接口表示队列。PriorityQueue类为优先队列实现Queue接口。

Collection接口表示存储在规则集或线性表中元素的集合。Map接口将键值映射到元素，键值类似于下标。在List中，下标是整数。而在Map中，键值可以是任意类型的对象。图中不能包含重复的键值。一个键值至多可以对应一个值。Map接口提供了查询、更新、获取值集合和键值集合的方法。

Java集合框架支持三种类型的图：散列图HashMap、链式散列图LinkedHashMap和树形图TreeMap。对于定位一个值、插入一个映射和删除一个映射而言，HashMap是很高效的。LinkedHashMap支持图中的条目排序。HashMap类中的条目是没有顺序的，但LinkedHashMap中的条目可以按某种顺序来获取，该顺序既可以是它们插入图中的顺序（称为插入顺序），也可以是它们最后一次访问的时间顺序，从最早到最晚（称为访问顺序）。对于遍历排好序的键值，TreeMap是高效的。键值可以使用Comparable接口来排序，也可以使用Comparator接口来排序。

01）集合框架（概述）

02）共性方法

1. /*
2.  * 1：add方法的参数类型都是Object。以便于接受任意类型的对象。
3.  * 2：集合中存储的都是对象的引用（地址）。
4.  */
5. public class
6. public static void
7.         System.out.println(obj);  
8.     }  
9. public static void
10.         method_1();  
11. "---------------分割线---------------");  
12.         method_2();  
13.     }  
14. public static void
15. //创建一个容器。使用Collection接口的子类。ArrayList。
16. new
17. //1：添加元素
18. "Java01");  
19. "Java02");  
20. "Java03");  
21. "Java04");  
22. //2：打印集合
23. "原集合 = "
24. "原集合 = "
25. //3：判断元素。
26. "判断Java02是否存在 = " + al.contains("Java02"));  
27. "判断集合是否为空 = "
28. //3：删除元素
29. "Java03");//删除指定元素。
30. 1);//删除下标为1的元素。
31. "删除后 = "
32. //4：获取个数。集合长度。
33. "清空前长度 = "
34. //5：清空集合。
35.         al.clear();  
36. "清空后集合 = "
37. "清空后长度 = "
38.     }  
39. public static void
40. new
41. "Java01");  
42. "Java02");  
43. "Java03");  
44. "Java04");  
45. "改变前a = "
46.           
47. new
48. "Java06");  
49. "Java05");  
50. "Java04");  
51. "Java03");  
52. "改变前b = "
53. "---------------分割线---------------");  
54.           
55. //取交集，a只会保留和b中相同的元素。
56.         sop(a.retainAll(b));  
57. "改变后a = "
58. "改变后b = "
59. "---------------分割线---------------");  
60.     }  
61. }

03）迭代器——Iterator

    
   
1. public class
2. public static void
3.         System.out.println(obj);  
4.     }  
5. public static void
6.         method_get();  
7.     }  
8. public static void
9. new
10. "Java01");//add(Object obj)
11. "Java02");  
12. "Java03");  
13. "Java04");  
14.           
15. //获取迭代器，用于取出集合中的元素。
16. while(it_1.hasNext()){//如果仍有元素可以迭代，则返回 true。
17. "While: " + it_1.next());//while代码相较for而言显的更少
18.         }  
19. "-----分割线-----");  
20. for
21. "For: " + it_2.next());//细节：for能尽可能的少用内存空间。
22.         }  
23.     }  
24. }

04）List集合共性方法

1. /*
2.  * Collection
3.  *      |--List：元素是有序的，元素可以重复。因为该集合体系有索引。
4.  *      |--Set：元素是无序，元素不可以重复。
5.  * 
6.  * List：特有方法。凡是可以操作角标的方法都是该体系特有的方法。
7.  * 
8.  * 增：add(index, element)：在列表的指定位置插入指定元素。
9.  *      addAll(index, Collection)：添加指定 collection 中的所有元素到此列表的结尾。
10.  * 删：remove(index)：移除列表中指定位置的元素。
11.  * 改：set(index, element)：用指定元素替换列表中指定位置的元素。
12.  * 查：get(index)：返回列表中指定位置的元素。
13.  *      subList(from, to)：返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图。
14.  *      listIterator();返回此列表元素的列表迭代器（按适当顺序）。
15.  *      int indexOf(obj):获取指定元素的位置。
16.  *      ListIterator listIterator()：
17.  * 
18.  *
19.  */
20. public class
21. public static void
22.         System.out.println(obj);  
23.     }  
24. public static void
25.         method_1();  
26.     }  
27. public static void
28. new
29. //添加元素。
30. "Java01");  
31. "Java02");  
32. "Java04");  
33. "原集合是： "
34.           
35. //在指定位置添加元素。
36. 2, "Java03");  
37. "第一次修改后是： "
38.           
39. //删除指定位置元素。
40. 3);  
41. "第二次修改后是： "
42.           
43. //通过下标获取元素。
44. "get(1): " + a.get(1));  
45. "-----分割线-----");  
46.           
47. //获取所有元素。
48. for (int i = 0; i < a.size(); i++)  
49. "a(" + i + ") = "
50. "-----分割线-----");  
51. //迭代器，获取所有元素。
52.         Iterator it = a.iterator();  
53. while(it.hasNext())  
54. "next = "
55.     }  
56. }

05）ListIterator

1. /*
2.  *  List集合特有的迭代器。
3.  *      ListIterator是Iterator的子接口。
4.  * 
5.  * 在迭代时，不可以通过集合对象的方法操作集合中的元素。
6.  * 因为会发生ConcurrentModificationException异常。
7.  * 
8.  * 所以，在迭代器时，只能用迭代器的放过操作元素，可是Iterator方法是有限的，
9.  * 只能对元素进行判断，取出，删除的操作。
10.  * 如果想要其他的操作如添加，修改等，就需要使用其子接口，ListIterator。
11.  * 
12.  * 该接口只能通过List集合的listIterator方法获取。
13.  */
14. public class
15. public static void
16.         System.out.println(obj);  
17.     }  
18. public static void
19.         method_1();  
20. "----------------------分割线----------------------");  
21.         method_2();  
22. "----------------------分割线----------------------");  
23.         method_3();  
24.     }  
25. public static void
26. new
27. //添加元素。
28. "Java01");  
29. "Java02");  
30. "Java03");  
31. "Java04");  
32. "原a = "
33.           
34. for
35. "（前面是否有元素）hasPrevious = " + it.hasPrevious());//判断前面是否有元素。
36.             Object obj = it.next();  
37. if (obj.equals("Java01"))  
38. "Java添加");  
39. if (obj.equals("Java03"))  
40. "Javahah");  
41. "（打印元素）obj = "
42. "------------------------------------------------");  
43.         }  
44. "修改后a = "
45.     }  
46. public static void
47. new
48. //添加元素。
49. "Java01");  
50. "Java02");  
51. "Java03");  
52. "Java04");  
53.           
54. //在迭代过程中，准备添加或者删除元素。
55. for
56. //          sop("Next = " + it.next());
57. //取出元素。
58. if(obj.equals("Java01"))  
59. //将Java01的引用在集合中删除。
60. "obj = "
61.         }  
62. "a = "
63.     }  
64. public static void
65. new
66. //添加元素。
67. "Java01");  
68. "Java02");  
69. "Java03");  
70. "Java04");  
71.           
72. //通过indexOf获取对象的位置。
73. "indexOf = " + a.indexOf("Java03"));  
74. //通过指定下标获取集合中的元素。
75. 1, 3);  
76. "sup = "
77.     }  
78. }

06）List集合具体对象的特点

1. /*
2.  * Collection
3.  *      |--List：元素是有序的，元素可以重复。因为该集合体系有索引。
4.  *          |--ArrayList：底层的数据结构使用的是数组结构。特点：查询速度很快。但是增删稍慢。线程不同步。
5.  *          |--LinkedList：底层使用的链表数据结构。特点：增删速度很快，查询稍慢。线程不同步。
6.  *          |--Vector：底层是数组数据结构。线程同步。被ArrayList替代了。因为效率低。
7.  *      |--Set：元素是无序，元素不可以重复。
8.  */

07）Vector中的枚举

1. /*
2.  * 枚举就是Vector特有的取出方式。
3.  * 发现枚举和迭代器很像。其实枚举和迭代器是一样的。
4.  * 
5.  * 因为枚举的名称以及方法的名称都过长。所以枚举被迭代器取代了。
6.  */
7. public class
8. public static void
9.         System.out.println(obj);  
10.     }  
11. public static void
12.         method_1();  
13.         method_2();  
14.     }  
15. public static void
16. new
17. "Java01");  
18. "Java02");  
19. "Java03");  
20. "Java04");  
21. "v1 = "
22. "-----------------------------------------");  
23. for
24. "it = " + it.next());//取数据
25.         }  
26. "-----------------------------------------");  
27.     }  
28. public static void
29. new
30. "Java01");  
31. "Java02");  
32. "Java03");  
33. "Java04");  
34. "v2 = "
35. "-----------------------------------------");  
36. for (Enumeration<E> en = v2.elements(); en.hasMoreElements();){//早期方式。
37. "en = "
38.         }  
39. "-----------------------------------------");  
40.     }  
41. }

08）LinkedList

1. /*
2.  * LinkedList特有方法：1.6之前。
3.  *      addFirst()：将指定元素插入此列表的开头。
4.  *      addLast()：将指定元素添加到此列表的结尾。
5.  *      getFirst()：返回此列表的第一个元素。
6.  *      getLast()：返回此列表的最后一个元素。
7.  *          ：获取元素，但不删除元素。长度不变。
8.  *          ：如果集合中没有元素，会出现NoSuchElementException。
9.  *      removeFirst()：移除并返回此列表的第一个元素。
10.  *      removeLast()：移除并返回此列表的最后一个元素。
11.  *          ：获取元素，并且删除元素。
12.  *          ：如果集合中没有元素，会出现NoSuchElementException。
13.  * 
14.  * 1.6开始出现的替代：
15.  *      offerFirst()：
16.  *      offerLast()：
17.  *      peekFirst()：
18.  *      peekLast()：
19.  *      poolFirst()：
20.  *      poolLast()：
21.  */
22. public class
23. public static void
24.         System.out.println(obj);  
25.     }  
26. public static void
27.         method_1();  
28.         method_2();  
29.     }  
30. public static void
31. new
32. "（2）Java01");  
33. "（3）Java02");  
34. "（1）Java03");//将元素添加到此列表的开头。
35. "（4）Java04");//将元素添加到此列表的尾部。
36. "add = "
37. "getFirst = "
38. "getLast = "
39. "------------------------------------------------------------------");  
40.   
41.     }  
42. public static void
43. new
44. "（1）Java01");//将元素添加到此列表的开头。
45. "（2）Java02");  
46. "（3）Java03");  
47. "（4）Java04");  
48. "（原）add = "
49. "remove(0) = " + link.remove(0));//获取下标为0的元素，并且删除该元素。
50. "（改）add = "
51. "------------------------------------------------------------------");  
52.           
53. for(; !link.isEmpty(); ){  
54. "jdk1.6 poolLast = "
55.         }  
56.     }  
57. }

09）LinkedList（练习）

1. /*
2.  * 使用LinkedList模拟一个堆栈或者队列数据结构。
3.  * 堆栈：先进后出。如同一个杯子。
4.  * 队列：先进先出。如同一根水管。
5.  */
6. public class
7. public static void
8.         System.out.println(obj);  
9.     }  
10. public static void
11.         useDuiLie();  
12. "-----------------------");  
13.         uesDuiZhan();  
14.     }  
15. public static void
16. new
17. "Java01");  
18. "Java02");  
19. "Java03");  
20. "Java04");  
21. while
22. "队列： "
23.     }  
24. public static void
25. new
26. "Java01");  
27. "Java02");  
28. "Java03");  
29. "Java04");  
30. while
31. "堆栈： "
32.     }  
33. }  
34. class
35. private
36.     DuiLie(){  
37. new
38.     }  
39. public void
40. //添加元素在队列最开头。
41.     }  
42. public
43. return link.pollLast();//从队列尾部开始取元素。
44.     }  
45. public boolean
46. return
47.     }  
48. }  
49.   
50. class
51. private
52.     DuiZhan(){  
53. new
54.     }  
55. public void
56. //添加元素在队列最开头。
57.     }  
58. public
59. return link.pollFirst();//从队列开头开始取元素。
60.     }  
61. public boolean
62. return
63.     }  
64. }

10）ArrayList（练习一）

1. /*
2.  * 去除ArrayList中重复的元素。
3.  */
4. public class
5. public static void
6.         System.out.println(obj);  
7.     }  
8. public static void
9.         method_1();  
10.     }  
11. public static void
12. new
13. "Java0");  
14. "Java1");  
15. "Java3");  
16. "Java2");  
17. "Java1");  
18. "Java2");  
19. "Al = "
20. "show(NewAl) = "
21.     }  
22. public static
23. new ArrayList();//创建一个新集合。
24. for
25. //依次打印元素
26. if (!newAl.contains(obj))//如果新集合中包不含有原集合的元素
27. //添加元素。
28.         }  
29. return newAl;//返回新集合。
30.     }  
31. }

11）ArrayList（练习二）

1. /*
2.  * 将自定义对象作为元素存到ArrayList集合中，并去除重复元素。
3.  * 比如：存人元素。同姓名，同年龄，视为同一元素。
4.  * 
5.  * 思路：
6.  * 1：对人描述，将数据封装人对象。
7.  * 2：定义容器，将人存入。
8.  * 3：取出。
9.  * 
10.  * List集合判断元素是否相同，依据的是元素的equals方法。
11.  */
12. public class
13. public static void
14.         System.out.println(obj);  
15.     }  
16. public static void
17.         method_1();  
18.         method_2();  
19.     }  
20. public static void
21. new
22. new Person("汤姆01号", 10));  
23. new Person("汤姆02号", 10));  
24. new Person("汤姆01号", 10));  
25. new Person("杰瑞01号", 11));  
26. new Person("杰瑞02号", 11));  
27. new Person("杰瑞01号", 11));  
28.         List al2 = show(al);  
29. for
30.             Person p = (Person)it.next();  
31. " "
32.         }  
33.     }  
34. public static void method_1(){//示例
35. new
36. new Person("汤姆01号", 10));  
37. new Person("汤姆02号", 10));  
38. new Person("汤姆01号", 10));  
39. new Person("杰瑞01号", 11));  
40. new Person("杰瑞02号", 11));  
41. new Person("杰瑞01号", 11));  
42. for
43.             Person p = (Person)it.next();  
44. " "
45.         }  
46. "------------------------------");  
47.     }  
48.       
49. public static
50. new ArrayList();//创建一个新集合。
51. for
52. //依次打印元素
53. if (!newAl.contains(obj))//如果新集合中包不含有原集合的元素
54. //添加元素。
55.         }  
56. return newAl;//返回新集合。
57.     }  
58. }  
59.   
60. class
61. private
62. private int
63. int
64. this.name = name;  
65. this.age = age;  
66.     }  
67. public boolean
68. if (!(obj instanceof
69. return false;  
70.         Person p = (Person)obj;  
71. return this.name.equals(p.name) && this.age == p.age;  
72.     }  
73. public
74. return
75.     }  
76. public int
77. return
78.     }  
79. }

12）HashSet

1. /*
2.  * |--Set：元素是无序（存入顺序和元素的位置不一致），元素不可以重复。
3.  *      |--HashSet：底层的数据结构是哈希表。
4.  *      |--TreeSet：
5.  * 
6.  * Set集合的功能和Collection接口的功能是一致的。
7.  */
8. public class
9. public static void
10.         System.out.println(obj);  
11.     }  
12. public static void
13.         method_1();  
14.     }  
15. public static void
16. new HashSet();//创建一个HashSet集合。无序。
17. "Java01"));//判断为true
18. "Java01"));//判断为false
19. "Java02");  
20. "Java03");  
21. "Java03"));//判断为false
22. "Java04");  
23. for
24.             sop(it.next());  
25.         }  
26.     }  
27. }

运行结果如下图所示：

13）HashSet存储自定义对象——复写hashCode和equals方法

1. /*
2.  * |--Set：元素是无序（存入顺序和元素的位置不一致），元素不可以重复。
3.  *      |--HashSet：底层的数据结构是哈希表。
4.  *          HashSet是如何保证元素唯一性的呢？
5.  *          是通过元素的两个方法，hasCode和equals来完成的。
6.  *          如果元素的hashCode值相同，才会判断equals是否为true。
7.  *          如果hashCode的值不同，就不会判断equals。
8.  *      |--TreeSet：
9.  * 
10.  * Set集合的功能和Collection接口的功能是一致的。
11.  */
12. public class
13. public static void
14.         System.out.println(obj);  
15.     }  
16. public static void
17.         method_1();  
18.     }  
19. public static void
20. new
21. new Person_2("汤姆（1）", 10));  
22. new Person_2("汤姆（2）", 10));  
23. new Person_2("汤姆（2）", 10)));//判断为false
24. new Person_2("汤姆（3）", 10));  
25. new Person_2("汤姆（3）", 10)));//判断为false
26. new Person_2("汤姆（4）", 10));  
27. for
28.             Person_2 p = (Person_2)it.next();  
29. " :: "
30.         }  
31.     }  
32. }  
33. class
34. private
35. private int
36. int
37. this.name = name;  
38. this.age = age;  
39.     }  
40. public int hashCode(){//细节：复写hashCode。集合底层内部自动调用。
41. return
42.     }  
43. public boolean equals(Object obj){//细节：复写equals。集合底层内部自动调用。
44. if (!(obj instanceof
45. return false;  
46.         Person_2 p = (Person_2)obj;  
47. return this.name.equals(p.name) && this.age == p.age;  
48.     }  
49. public
50. return
51.     }  
52. public int
53. return
54.     }  
55. }<span style="white-space:pre"> </span>

14）HashSet判断和删除的依据

对于元素是否存在，以及删除等操作，依赖的方法是元素的hashCode和equals方法。