释放双眼，带上耳机，听听看~！
JAVA之旅（十九）——ListIterator列表迭代器，List的三个子类对象，Vector的枚举，LinkedList,ArrayList和LinkedList的小练习
关于数据结构，所讲的知识太多了，我们只能慢慢的来分析了
一.ListIterator列表迭代器
ListIterator列表迭代器是个什么鬼？我们通过一个小例子来认识他
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
2
3import java.util.ArrayList;
4import java.util.Iterator;
5
6import javax.print.attribute.standard.MediaSize.Other;
7
8//公共的 类 类名
9public class HelloJJAVA {
10 public static void main(String[] args) {
11 listiterator();
12 }
13
14 /**
15 * 演示列表迭代器
16 */
17 public static void listiterator() {
18 /**
19 * 需求：对集合中的元素取出，在取的过程中进行操作
20 */
21 ArrayList al = new ArrayList<>();
22 al.add("hello 01");
23 al.add("hello 02");
24 al.add("hello 03");
25 al.add("hello 04");
26
27 // 在迭代过程中，准备添加或者删除元素
28 Iterator it = al.iterator();
29 while (it.hasNext()) {
30 Object obj = it.next();
31
32 if (obj.equals("hello 02")) {
33 // 将这个元素删除
34 al.add("hello 05");
35 sop(obj);
36 }
37 }
38 }
39
40 /**
41 * 输出
42 */
43 public static void sop(Object obj) {
44 System.out.println(obj);
45 }
46
47}
48
49
我们用老方法的思路去做我们的需求，是这样的，你运行后悔发现
他打印了02缺报异常了，我们于是要去查看API
他不清楚怎么去操作，这也是这个迭代器的缺陷
- list集合特有的迭代器叫做ListIterator，是Iterator的子接口，在迭代时，不可以通过集合对象的方法操作集合中的元素，因为会发现并发修改异常，所以，在迭代器时，只能用迭代器的方式操作元素，可是Iterator方法有限，如果想要其他的操作如添加，修改等，就需要使用其子接口：ListIterator，该接口只能通过list集合的ListIterator方法获取
所以我们可以这样去修改
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
2
3import java.util.ArrayList;
4import java.util.Iterator;
5import java.util.ListIterator;
6
7//公共的 类 类名
8public class HelloJJAVA {
9 public static void main(String[] args) {
10 listiterator();
11 }
12
13 /**
14 * 演示列表迭代器
15 */
16 public static void listiterator() {
17 /**
18 * 需求：对集合中的元素取出，在取的过程中进行操作
19 */
20 ArrayList al = new ArrayList<>();
21 al.add("hello 01");
22 al.add("hello 02");
23 al.add("hello 03");
24 al.add("hello 04");
25
26 sop(al);
27
28 ListIterator li = al.listIterator();
29 while (li.hasNext()) {
30 Object object = li.next();
31 if (object.equals("hello 03")) {
32 li.add("lgl");
33 }
34
35 }
36 sop(al);
37
38 // 在迭代过程中，准备添加或者删除元素
39 // Iterator it = al.iterator();
40 // while (it.hasNext()) {
41 // Object obj = it.next();
42 //
43 // if (obj.equals("hello 02")) {
44 // // 将这个元素删除
45 // // al.add("hello 05");
46 // it.remove();
47 // sop(obj);
48 // }
49 // sop(al);
50 // }
51 }
52
53 /**
54 * 输出
55 */
56 public static void sop(Object obj) {
57 System.out.println(obj);
58 }
59
60}
61
62
不仅可以增加，还可以修改，删除等操作
二.List的三个子类对象
List有三个子类对象
- ArrayList
- LinkedList
- Vector
为什么会有三个？因为底层的数据结构不一样，那具体是怎么样的呢？
-
ArrayList
-
底层的数据结构使用的是数组结构，特点：查询速度很快，但是增删稍慢，元素不多的话，你体会不到的。线程不同步。
-
LinkedList
-
底层使用的链表数据结构，特点：增删的速度很快，查询的速度慢。
-
Vector
-
底层是数组数据结构，线程同步。做什么都慢，被ArrayList替代了
ArrayList和Vector都是数组结构，他们有什么具体的区别呢？
- ArrayList构造一个初始容量为10的空列表，当长度超过10之后增加50%,而后者，长度也为10，超过的话，是100%延长至20，比较浪费空间
三.Vector的枚举
上面说了这么多，虽然Vector不用，但是我们还是要熟悉一下，面试的时候也是会问到的，所以我们写个小例子
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
2
3import java.util.Enumeration;
4import java.util.Vector;
5
6//公共的 类 类名
7public class HelloJJAVA {
8 public static void main(String[] args) {
9 Vector v = new Vector();
10
11 v.add("hello 01");
12 v.add("hello 02");
13 v.add("hello 03");
14 v.add("hello 04");
15
16 // 返回枚举
17 Enumeration elements = v.elements();
18 while (elements.hasMoreElements()) {
19 sop(elements.nextElement());
20 }
21 }
22
23 /**
24 * 输出
25 */
26 public static void sop(Object obj) {
27 System.out.println(obj);
28 }
29
30}
31
32
这样就输出了
枚举就是Vector特有的取出方式，我们发现枚举和迭代器很像，其实枚举和迭代时一样的，因为枚举的名称以及方法的名称都过长，所以被迭代器所取代了。枚举就郁郁而终了
四.LinkedList
我们继续来说list的子类对象LinkedList，事实上区别都不是很大，所以我们只说一些特有的特点
LinkedList特有方法：
- addFirst()
- addLast();
- getFirst();
- getLast();
- removeFirst();
- removeLast();
我们来看
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
2
3import java.util.LinkedList;
4
5//公共的 类 类名
6public class HelloJJAVA {
7 public static void main(String[] args) {
8
9 LinkedList list = new LinkedList<>();
10
11 list.addFirst("hello 0");
12 list.addFirst("hello 1");
13 list.addFirst("hello 2");
14 list.addFirst("hello 3");
15
16 sop(list);
17 }
18
19 /**
20 * 输出
21 */
22 public static void sop(Object obj) {
23 System.out.println(obj);
24 }
25
26}
27
28
输出的结果
我们一直添加头部，就是倒序了，这个逻辑应该都知道吧！要是addLast()，那就是顺序了，我们要想知道他们的头部和尾部的数值，也就直接get就是了
2
3
2 sop(list.getLast());
3
获取元素，但是元素被删除，如果集合中没有元素，会出异常，在JDK1.6版本后出现了替代方法
-
offerFirst();
-
offerLast();
-
peekFirst();
-
peekLast();
-
pollFist();
-
pollLast();
之类的
五.小练习
我们写个小练习吧，我们先看LinkedList
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
2
3import java.util.LinkedList;
4
5//公共的 类 类名
6public class HelloJJAVA {
7 public static void main(String[] args) {
8 /**
9 * 使用LinkedList模拟一个堆栈或者队列数据模式 堆栈：现进后出 队列：先进先出
10 */
11 DuiLie dl = new DuiLie();
12 dl.MyAdd("hello 01");
13 dl.MyAdd("hello 02");
14 dl.MyAdd("hello 03");
15 dl.MyAdd("hello 04");
16
17 while (!dl.isNull()) {
18 sop(dl.myGet());
19 }
20
21 }
22
23 /**
24 * 输出
25 */
26 public static void sop(Object obj) {
27 System.out.println(obj);
28
29 }
30
31}
32
33/**
34 * 队列
35 *
36 * @author LGL
37 *
38 */
39class DuiLie {
40
41 private LinkedList link;
42
43 public DuiLie() {
44 link = new LinkedList<>();
45 }
46
47 public void MyAdd(Object obj) {
48 link.addFirst(obj);
49 }
50
51 public Object myGet() {
52 return link.removeLast();
53 }
54
55 public boolean isNull() {
56 return link.isEmpty();
57 }
58
59}
60
61
自己写的一个链表，去使用它，这样输出的结果就是
OK，那我们继续，写一个ArrayList的小例子
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
2
3import java.util.ArrayList;
4import java.util.Iterator;
5import java.util.LinkedList;
6
7//公共的 类 类名
8public class HelloJJAVA {
9 public static void main(String[] args) {
10 /**
11 * 去除ArrayList的重复元素
12 */
13
14 ArrayList list = new ArrayList<>();
15
16 list.add("Hello 01");
17 list.add("Hello 02");
18 list.add("Hello 03");
19 list.add("Hello 02");
20 list.add("Hello 05");
21
22 sop(list);
23 list = Method(list);
24 sop(list);
25
26 }
27
28 public static ArrayList Method(ArrayList list){
29 //临时容器
30 ArrayList newList = new ArrayList<>();
31 Iterator iterator = list.iterator();
32 while (iterator.hasNext()) {
33 Object object = (Object) iterator.next();
34
35 if(!newList.contains(object)){
36 newList.add(object);
37 }
38 }
39 return newList;
40 }
41
42 /**
43 * 输出
44 */
45 public static void sop(Object obj) {
46 System.out.println(obj);
47
48 }
49
50}
51
52
输出的结果
好的，我们本篇幅到这里，就写完了，但是我们的数据结构只是讲了一些皮毛而已，我们接下来的几天，将会一一为大家讲解
