7.1集合框架
为什么出现集合类？
面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。
数组和集合类同是容器，有何不同？
数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。数组中可以存储基本数据类型，集合只能存储对象。
集合类的特点
集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。
7.1.2Collection定义了集合框架的共性功能。
1.添加
add(e);
addAll(collection);
2.删除
remove(e);
removeAll(collection);
clear();
3.判断。
contains(e);
isEmpty();
4.获取
iterator();
size();
5.获取交集。
retainAll();
6.集合变数组。
toArray();
1. add方法的参数类型是Object。以便于接收任意类型对象。
2. 集合中存储的都是对象的引用(地址)
什么是迭代器呢？
其实就是集合的取出元素的方式。
如同抓娃娃游戏机中的夹子。
迭代器是取出方式，会直接访问集合中的元素。
所以将迭代器通过内部类的形式来进行描述。
通过容器的iterator()方法获取该内部类的对象。
练习一：Collection接口中常见操作
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100import java.util.*; class CollectionDemo { public static void main(String[] args) { method_get(); } public static void method_get() { ArrayList al = new ArrayList(); //1，添加元素。 al.add("java01");//add(Objectobj); al.add("java02"); al.add("java03"); al.add("java04"); /* Iterator it = al.iterator();//获取迭代器，用于取出集合中的元素。 while(it.hasNext()) { sop(it.next()); } */ for(Iteratorit = al.iterator(); it.hasNext() ; ) //老外用的是for循环的方法迭代，优点是循环完后创建的对象自动释放，而while那种是先创建对象，对象在调用完不会自动释放。 { sop(it.next()); } } public static void method_2() { ArrayList al1 = new ArrayList(); al1.add("java01"); al1.add("java02"); al1.add("java03"); al1.add("java04"); ArrayListal2 = new ArrayList(); al2.add("java03"); al2.add("java04"); al2.add("java05"); al2.add("java06"); //al1.retainAll(al2);//取交集，al1中只会保留和al2中相同的元素。 al1.removeAll(al2);//删除，al1和al2中相同的元素。 sop("al1:"+al1); sop("al2:"+al2); } public static void base_method() { //创建一个集合容器。使用Collection接口的子类。ArrayList ArrayListal = new ArrayList(); //1，添加元素。 al.add("java01");//add(Objectobj); al.add("java02"); al.add("java03"); al.add("java04"); //打印原集合。 sop("原集合:"+al); //3，删除元素。 //al.remove("java02"); //al.clear();//清空集合。 //4，判断元素。 sop("java03是否存在:"+al.contains("java03")); sop("集合是否为空？"+al.isEmpty()); //2，获取个数。集合长度。 sop("size:"+al.size()); //打印改变后的集合。 sop(al); } public static void sop(Object obj) { System.out.println(obj); } }
7.1.3 Collection分类
|--List:元素是有序的，元素可以重复。因为该集合体系有索引。
|--ArrayList:底层的数据结构使用的是数组结构。特点：查询速度很快。但是增删稍慢。线程不同步。
|--LinkedList:底层使用的链表数据结构。特点：增删速度很快，查询稍慢。线程不同步。
|--Vector:底层是数组数据结构。线程同步。被ArrayList替代了。因为效率低。
|--Set：元素是无序，元素不可以重复。、
List：
特有方法。凡是可以操作角标的方法都是该体系特有的方法。
增
add(index,element);
addAll(index,Collection);
删
remove(index);
改
set(index,element);
查
get(index):
subList(from,to);
listIterator();
intindexOf(obj):获取指定元素的位置。
ListIteratorlistIterator();
List集合特有的迭代器。ListIterator是Iterator的子接口。
在迭代时，不可以通过集合对象的方法操作集合中的元素。
因为会发生ConcurrentModificationException异常。
所以，在迭代器时，只能用迭代器的放过操作元素，可是Iterator方法是有限的，
只能对元素进行判断，取出，删除的操作，
如果想要其他的操作如添加，修改等，就需要使用其子接口，ListIterator。
该接口只能通过List集合的listIterator方法获取。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111import java.util.*; class ListDemo { public static void sop(Object obj) { System.out.println(obj); } public static void method() { ArrayList al = new ArrayList(); //添加元素 al.add("java01"); al.add("java02"); al.add("java03"); sop("原集合是："+al); //在指定位置添加元素。 al.add(1,"java09"); //删除指定位置的元素。 //al.remove(2); //修改元素。 //al.set(2,"java007"); //通过角标获取元素。 sop("get(1):"+al.get(1)); sop(al); //获取所有元素。 for(int x=0; x<al.size(); x++) { System.out.println("al("+x+")="+al.get(x)); } Iterator it = al.iterator(); while(it.hasNext()) { sop("next:"+it.next()); } //通过indexOf获取对象的位置。 sop("index="+al.indexOf("java02")); List sub = al.subList(1,3); sop("sub="+sub); } public static void main(String[] args) { //演示列表迭代器。 ArrayList al = new ArrayList(); //添加元素 al.add("java01"); al.add("java02"); al.add("java03"); sop(al); ListIterator li = al.listIterator(); //sop("hasPrevious():"+li.hasPrevious()); while(li.hasNext()) { Object obj = li.next(); if(obj.equals("java02")) //li.add("java009"); li.set("java006"); } while(li.hasPrevious()) { sop("pre::"+li.previous()); } sop(al); /* //在迭代过程中，准备添加或者删除元素。 Iterator it = al.iterator(); while(it.hasNext()) { Object obj = it.next(); if(obj.equals("java02")) //al.add("java008"); it.remove();//将java02的引用从集合中删除了。 sop("obj="+obj); } sop(al); */ } }
7.1.4Vector的应用
枚举就是Vector特有的取出方式。
发现枚举和迭代器很像。
其实枚举和迭代是一样的。
因为枚举的名称以及方法的名称都过长。
所以被迭代器取代了。
枚举郁郁而终了。
练习二：List接口中 Vector集合
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21import java.util.*; class VectorDemo { public static void main(String[] args) { Vector v = new Vector(); v.add("java01"); v.add("java02"); v.add("java03"); v.add("java04"); Enumeration en = v.elements(); while(en.hasMoreElements()) { System.out.println(en.nextElement()); } } }
7.1.5LinkedList:特有方法：
addFirst();
addLast();
getFirst();
getLast();
获取元素，但不删除元素。如果集合中没有元素，会出现NoSuchElementException
removeFirst();
removeLast();
获取元素，但是元素被删除。如果集合中没有元素，会出现NoSuchElementException
在JDK1.6出现了替代方法。
offerFirst();
offerLast();
peekFirst();
peekLast();
获取元素，但不删除元素。如果集合中没有元素，会返回null。
pollFirst();
pollLast();
获取元素，但是元素被删除。如果集合中没有元素，会返回null。
练习三：LinkedList:特有方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33import java.util.*; class LinkedListDemo { public static void main(String[] args) { LinkedList link = new LinkedList(); link.addLast("java01"); link.addLast("java02"); link.addLast("java03"); link.addLast("java04"); //sop(link); // sop(link.getFirst()); // sop(link.getFirst()); //sop(link.getLast()); //sop(link.removeFirst()); //sop(link.removeFirst()); //sop("size="+link.size()); while(!link.isEmpty()) { sop(link.removeLast()); } } public static void sop(Object obj) { System.out.println(obj); } }
7.1.6使用LinkedList模拟一个堆栈或者队列数据结构。
堆栈：先进后出 如同一个杯子。
队列：先进先出 Firstin First out FIFO 如同一个水管。
练习四：使用LinkedList模拟一个堆栈或者队列数据结构
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41import java.util.*; class DuiLie { private LinkedList link; DuiLie() { link= new LinkedList(); } public void myAdd(Object obj) { link.addFirst(obj); } public Object myGet() { return link.removeFirst(); } public boolean isNull() { return link.isEmpty(); } } class LinkedListTest { public static void main(String[] args) { DuiLie dl = new DuiLie(); dl.myAdd("java01"); dl.myAdd("java02"); dl.myAdd("java03"); dl.myAdd("java04"); while(!dl.isNull()) { System.out.println(dl.myGet()); } } }
练习五：去除ArrayList集合中的重复元素。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59import java.util.*; class ArrayListTest { public static void sop(Object obj) { System.out.println(obj); } public static void main(String[] args) { ArrayList al = new ArrayList(); al.add("java01"); al.add("java02"); al.add("java01"); al.add("java02"); al.add("java01"); // al.add("java03"); /* 在迭代时循环中next调用一次，就要hasNext判断一次。 Iteratorit = al.iterator(); while(it.hasNext()) { sop(it.next()+"...."+it.next()); } */ /**/ sop(al); al= singleElement(al); sop(al); } public static ArrayList singleElement(ArrayList al) { //定义一个临时容器。 ArrayList newAl = new ArrayList(); Iterator it = al.iterator(); while(it.hasNext()) { Object obj = it.next(); if(!newAl.contains(obj)) newAl.add(obj); } return newAl; } }
练习六：将自定义对象作为元素存到ArrayList集合中，并去除重复元素
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105import java.util.*; /* 将自定义对象作为元素存到ArrayList集合中，并去除重复元素。 比如：存人对象。同姓名同年龄，视为同一个人。为重复元素。 思路： 1，对人描述，将数据封装进人对象。 2，定义容器，将人存入。 3，取出。 List集合判断元素是否相同，依据是元素的equals方法。 */ class Person { private String name; private int age; Person(Stringname,int age) { this.name= name; this.age= age; } public boolean equals(Object obj) { if(!(obj instanceof Person)) return false; Personp = (Person)obj; //System.out.println(this.name+"....."+p.name); return this.name.equals(p.name) && this.age == p.age; } /**/ public String getName() { return name; } public int getAge() { return age; } } class ArrayListTest2 { public static void sop(Object obj) { System.out.println(obj); } public static void main(String[] args) { ArrayList al = new ArrayList(); al.add(newDemo()); al.add(newPerson("lisi01",30));//al.add(Object obj);//Object obj = newPerson("lisi01",30); //al.add(newPerson("lisi02",32)); al.add(newPerson("lisi02",32)); al.add(newPerson("lisi04",35)); al.add(newPerson("lisi03",33)); //al.add(newPerson("lisi04",35)); //al= singleElement(al); sop("remove03 :"+al.remove(new Person("lisi03",33)));//remove方法底层也是依赖于元素的equals方法。 Iterator it = al.iterator(); while(it.hasNext()) { Person p = (Person)it.next(); sop(p.getName()+"::"+p.getAge()); } } public static ArrayList singleElement(ArrayList al) { //定义一个临时容器。 ArrayList newAl = new ArrayList(); Iterator it = al.iterator(); while(it.hasNext()) { Object obj = it.next(); if(!newAl.contains(obj)) newAl.add(obj); } return newAl; } }
7.1.7HashSet集合
|--Set：元素是无序(存入和取出的顺序不一定一致)，元素不可以重复。、
|--HashSet:底层数据结构是哈希表。是线程不安全的。不同步。
HashSet是如何保证元素唯一性的呢？
是通过元素的两个方法，hashCode和equals来完成。
如果元素的HashCode值相同，才会判断equals是否为true。
如果元素的hashcode值不同，不会调用equals。
注意,对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashcode和equals方法。
|--TreeSet：
Set集合的功能和Collection是一致的。
练习七：HashSet集合练习
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28import java.util.*; class HashSetDemo { public static void sop(Object obj) { System.out.println(obj); } public static void main(String[] args) { HashSet hs = new HashSet(); sop(hs.add("java01")); sop(hs.add("java01")); hs.add("java02"); hs.add("java03"); hs.add("java03"); hs.add("java04"); Iterator it = hs.iterator(); while(it.hasNext()) { sop(it.next()); } } }
练习八：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74import java.util.*; /* 往hashSet集合中存入自定对象 姓名和年龄相同为同一个人，重复元素。 */ class HashSetTest { public static void sop(Object obj) { System.out.println(obj); } public static void main(String[] args) { HashSet hs = new HashSet(); hs.add(newPerson("a1",11)); hs.add(newPerson("a2",12)); hs.add(newPerson("a3",13)); // hs.add(newPerson("a2",12)); // hs.add(newPerson("a4",14)); //sop("a1:"+hs.contains(newPerson("a2",12))); // hs.remove(newPerson("a4",13)); Iterator it = hs.iterator(); while(it.hasNext()) { Person p = (Person)it.next(); sop(p.getName()+"::"+p.getAge()); } } } class Person { private String name; private int age; Person(String name,int age) { this.name= name; this.age= age; } public int hashCode() { System.out.println(this.name+"....hashCode"); return name.hashCode()+age*37; } public boolean equals(Object obj) { if(!(obj instanceof Person)) return false; Person p = (Person)obj; System.out.println(this.name+"...equals.."+p.name); return this.name.equals(p.name) && this.age == p.age; } public String getName() { return name; } public int getAge() { return age; } }
最后
以上就是机智毛衣最近收集整理的关于【14】集合1_集合框架，迭代器，List集合，Set集合的全部内容，更多相关【14】集合1_集合框架内容请搜索靠谱客的其他文章。
发表评论 取消回复