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