Java集合框架（一）

什么是集合框架

Java语言的设计者对常用的数据结构和算法做了一些规范（接口）和实现（实现接口的类）。所有抽象出来的数据结构和操作（算法）统称为集合框架

集合与数组的区别

1. 数组长度固定，集合长度不固定
2. 数组可以存储基本类型和引用类型，集合只能存储引用类型

Collection体系

Collection 接口

特点：代表一组任意类型的对象，无序、无下标、不能重复。JDK不提供此接口的任何直接实现：它提供了更具体的子接口的实现，如Set和List 。

创建集合: Collection collection = new ArrayList();

(使用Collection 接口的 ArrayList 实现类来调用 Collection 的方法。)

Collection是 List 接口和 Set 接口的父接口，通常情况下不被直接使用。所以Collection 接口定义了一些通用的方法，通过这些方法可以实现对集合的基本操作。因为 List 接口和 Set 接口继承自 Collection 接口，所以也可以调用这些方法。

常用方法

方法	描述
add(E e)	向集合中添加一个元素，E指的是e元素的数据类型
int size()	返回集合中元素的个数，也叫集合的大小
addAll(Collection c)	向集合中添加集合 c 中的所有元素
remove(Object o)	删除一个指定元素
removeAll(Collection c)	删除指定集合中包含的所有此集合的元素
clear()	清除所有元素
contains(Object o)	判断集合中是否包含指定元素
containsAll(Collection c)	判断集合中是否包含集合 c 中的所有元素
isEmpty()	判断集合是否为空
retainAll(Collection c)	仅保留集合 c 中出现的元素
Iterato < E >iterator()	返回一个 Iterator 对象，用于遍历集合中的元素

Iterator接口(迭代器)

方法	描述
boolean hasNext()	如果迭代具有更多元素，则返回 true
E next()	返回迭代中的下一个元素
default void remove()	从底层集合中删除此迭代器返回的最后一个元素（可选操作）。

add()方法、size()方法、addAll方法、remove()方法、removeAll()方法、clear()方法

【演示】

package com.gather.collection;

import java.util.ArrayList;
import java.util.Collection;
/*
add()方法、size()方法、addAll方法
remove()方法、removeAll()方法、clear()方法
 */
public class Demo01 {
    public static void main(String[] args) {
        Collection cet1 = new ArrayList();// 创建集合cet1
        Collection cet2 = new ArrayList();// 创建集合cet2
        cet1.add(1);// 向cet1中添加元素
        cet1.add(2);
        cet1.add(3);
        cet1.add(4);
        cet2.add(8);// 向cet2中添加元素
        cet2.add(9);
        System.out.println("cet1中元素个数="+cet1.size());// 返回集合的大小
        System.out.println("cet1中的元素："+cet1.toString());
        cet2.addAll(cet1);// 将cet1中所有元素添加到cet2中
        cet2.remove(3);// 删除集合cet2中的元素3
        System.out.println("cet2中的元素："+cet2.toString());
        cet2.removeAll(cet1);// 删除cet2中包含的所有cet1中的元素
        System.out.println("cet2删除c包含et1中元素的元素："+cet2.toString());
        cet2.clear();// 清除cet2中的所有元素
    }
}
执行结果：
cet1中元素个数=4
cet1中的元素：[1, 2, 3, 4]
cet2中的元素：[8, 9, 1, 2, 4]
cet2删除c包含et1中元素的元素：[8, 9]

contains()方法、containsAll()方法、isEmpty()方法、retainAll()方法

【演示】

package com.gather.collection;

import java.util.ArrayList;
import java.util.Collection;
/*
contains()方法、containsAll()方法、isEmpty()方法、retainAll()方法
 */
public class Demo02 {
    public static void main(String[] args) {
        Collection cet1 = new ArrayList();// 创建集合cet1
        Collection cet2 = new ArrayList();// 创建集合cet2
        cet1.add(1);// 向cet1中添加元素
        cet1.add(2);
        cet1.add(3);
        cet1.add(4);
        cet2.add(8);// 向cet2中添加元素
        cet2.add(9);
        System.out.println(cet1.contains(2));// 判断cet1中是否包含2
        System.out.println(cet2.containsAll(cet1));// 判断cet2中是否包含集合cet1中的所有元素
        System.out.println(cet2.isEmpty());// 判断集合cet2是否为空
        cet2.addAll(cet1);// 将cet1中所有元素添加到cet2中
        cet2.retainAll(cet1);// cet2中仅保留cet1中所出现的元素
        System.out.println(cet2.toString());
    }
}
执行结果：
true
false
false
[1, 2, 3, 4]

集合中元素的遍历

【演示1】

package com.gather.collection;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class Demo04 {
    public static void main(String[] args) {
        Collection cet1 = new ArrayList();// 创建集合cet1
        cet1.add(1);// 向cet1中添加元素
        cet1.add(2);
        cet1.add(8);
        cet1.add(9);
        System.out.println("cet1的元素个数："+cet1.size());
        /*
        使用增强for循环遍历
         */
        for (Object obj: cet1) {
            Integer i = (Integer)obj;
            System.out.println(i.toString());
        }
        /*
        使用迭代器遍历
        迭代过程中不能使用Collection的删除方法
        haNext(); 有没有下一个元素
		next(); 获取下一个元素
		remove(); 删除当前元素
         */
        Iterator it = cet1.iterator();
        while (it.hasNext()) {
            Integer i = (Integer)it.next();
            System.out.println(i.toString());
            it.remove();
            //cet1.remove(1);迭代过程中不能使用Collection的删除方法:并发修改异常
        }
        System.out.println("删除后cet1的元素个数："+cet1.size());
    }
}
执行结果：
cet1的元素个数：4
1
2
8
9
1
2
8
9
删除后cet1的元素个数：0

【演示2】

package com.gather.collection;

public class Student {
    private String name;
    private int age;

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student["+this.name+","+this.age+"]";
    }
}

package com.gather.collection;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class Demo03 {
    public static void main(String[] args) {
        Student s1 = new Student("张三",18);
        Student s2 = new Student("李四",20);
        Student s3 = new Student("王五",15);
        Collection c1 = new ArrayList();
        c1.add(s1);// 添加学生对象
        c1.add(s2);
        c1.add(s3);
        c1.add(s3);// ArrayList 实现类元素可重复
        System.out.println("元素个数"+c1.size());
        System.out.println(c1.toString());
        /*
        使用增强for循环遍历
         */
        for (Object obj: c1) {
            Student s = (Student)obj;
            System.out.println(s.toString());
        }
        /*
        使用迭代器遍历
        迭代过程中不能使用Collection的删除方法
        haNext(); 有没有下一个元素
		next(); 获取下一个元素
		remove(); 删除当前元素
         */
        Iterator it = c1.iterator();
        while (it.hasNext()) {
            Student s = (Student)it.next();
            System.out.println(s.toString());
            it.remove();// Iterator类中的remove方法删除当前元素
        }
        System.out.println(c1.size());
    }
}
执行结果：
元素个数4
[Student[张三,18], Student[李四,20], Student[王五,15], Student[王五,15]]
Student[张三,18]
Student[李四,20]
Student[王五,15]
Student[王五,15]
Student[张三,18]
Student[李四,20]
Student[王五,15]
Student[王五,15]
0

List接口

list接口是Collection接口的子类，其继承了Collection接口的所有方法，但也有其独有的方法。

List接口的特点：

1. 它是一个元素存取有序的集合。
2. 它是一个带有索引的集合，通过索引就可以精确的操作集合中的元素。
3. 集合中可以有重复的元素，通过元素的equals方法，来比较是否为重复的元素

常用方法

方法	描述
void add(int index,E element)	将指定的元素插入此列表中的指定位置（可选操作）
E get(int index)	返回此列表中指定位置的元素
E remove(int index)	从列表中删除指定元素的第一个出现（如果存在）（可选操作）
E set(int index,E element)	用指定的元素（可选操作）替换此列表中指定位置的元素
List subList(int fromIndex,int toIndex)	返回此列表中指定的 fromIndex （含）和 toIndex之间的集合元素

ListIterator接口方法(列表迭代器)

ListIterator接口是Iterator接口的子类，继承了Iterator的所有方法。

ListIterator独有的方法

方法	描述
void add(E e)	将指定的元素插入列表（可选操作）
boolean hasPrevious()	返回 true如果遍历反向列表，列表迭代器有多个元素
int nextIndex()	返回随后调用 next()返回的元素的索引
E previous()	返回列表中的上一个元素，并向后移动光标位置
int previousIndex()	返回由后续调用 previous()返回的元素的索引
void set(E e)	用 指定的元素替换由 next()或 previous()返回的最后一个元素（可选操作

add()方法、get()方法、remove()方法、set()方法

【演示】

package com.gather.list;

import java.util.ArrayList;
import java.util.List;

public class Demo01 {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("张三");
        list.add("李四");
        list.add("王五");
        System.out.println("最初的元素列表" + list.toString());
        list.add(0, "赵六");// 将"赵六"插入此列表第0位
        System.out.println("指定位置添加后的元素列表" + list.toString());
        System.out.println("第2位元素为：" + list.get(2));// 获取此列表第2位的元素
        list.remove(3);// 删除此列表的第3位元素
        System.out.println("删除后的元素列表" + list.toString());
        list.set(0, "张三");// 用"张三"替换此列表第0位的元素（可以有重复的元素）
        System.out.println("替换后的元素列表" + list.toString());
    }
}
执行结果：
最初的元素列表[张三, 李四, 王五]
指定位置添加后的元素列表[赵六, 张三, 李四, 王五]
第2位元素为：李四
删除后的元素列表[赵六, 张三, 李四]
替换后的元素列表[张三, 张三, 李四]

集合中元素遍历

利用for循环遍历

package com.gather.list;

import java.util.ArrayList;
import java.util.List;

public class Demo02 {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("小米");
        list.add("华为");
        list.add("苹果");
        for (int i = 0; i < list.size(); i++) {
            String str = (String) list.get(i);
            System.out.println(str);
        }
        System.out.println("---------分隔--------");
        for (Object obj : list) {
            String str = (String) obj;
            System.out.println(str);
        }
    }
}
执行结果：
小米
华为
苹果
---------分隔--------
小米
华为
苹果

利用迭代器遍历

package com.gather.list;

public class Student {
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "[" + this.name + "," + this.age + "]";
    }
}

package com.gather.list;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class Demo03 {
    public static void main(String[] args) {
        Student s1 = new Student("小明", 12);
        Student s2 = new Student("小红", 15);
        Student s3 = new Student("小王", 10);
        Student s4 = new Student("小亮", 8);
        List list = new ArrayList();
        list.add(s1);
        list.add(s2);
        list.add(0, s3);
        list.add(0, s4);
        /*
        利用Iterator接口
         */
        Iterator it = list.iterator();
        System.out.println("---------Iterator遍历--------");
        while (it.hasNext()) {
            Student s = (Student) it.next();
            System.out.println(s.toString());
        }
        /*
        利用listIterator接口
         */
        ListIterator lit = list.listIterator();
        System.out.println("---------listIterator正序遍历--------");
        while (lit.hasNext()) {// 正序遍历
            int x = lit.nextIndex();// 返回随后调用 next()返回的元素的索引
            Student s = (Student) lit.next();
            System.out.println(x + "-->" + s.toString());
        }
        System.out.println("---------listIterator逆序遍历--------");
        while (lit.hasPrevious()) {// 逆序遍历（上面正序遍历完之后，指针正好指向最后一个元素）
            int y = lit.previousIndex();// 返回由后续调用 previous()返回的元素的索引
            Student s = (Student) lit.previous();// 返回列表中的上一个元素，并向后移动光标位置
            System.out.println(y + "-->" + s.toString());
        }
    }
}
执行结果：
---------Iterator遍历--------
[小亮,8]
[小王,10]
[小明,12]
[小红,15]
---------listIterator正序遍历--------
0-->[小亮,8]
1-->[小王,10]
2-->[小明,12]
3-->[小红,15]
---------listIterator逆序遍历--------
3-->[小红,15]
2-->[小明,12]
1-->[小王,10]
0-->[小亮,8]

集合添加数据(自动装箱)&subList()方法

package com.gather.list;

import java.util.ArrayList;
import java.util.List;

public class Demo04 {
    public static void main(String[] args) {
        List list = new ArrayList();
        /*
        添加数据类型：自动装箱
        int----->----Integer
         */
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        list.add(6);
        System.out.println(list.toString());
        list.remove(1);// 从列表中删除下标为1的元素（调用的是List接口中的方法：remove(int index)）
        System.out.println(list.toString());
        list.remove((Object) 1);// 从列表中删除为1的元素（调用的是Collection接口中的方法：remove(Object o)）
        //list.remove(new Integer(1)); //从列表中删除为1的元素
        System.out.println(list.toString());
        List list2 = list.subList(1, 3);// 返回list列表中[1,3)的集合元素(含头不含尾)
        System.out.println("list2：" + list2.toString());
    }
}
执行结果：
[1, 2, 3, 4, 5, 6]
[1, 3, 4, 5, 6]
[3, 4, 5, 6]
list2：[4, 5]

List实现类

List接口一共有三个实现类：ArrayList、Vector和LinkedList

其中ArrayList和Vector都是利用数组这一个数据结构实现的，所以具有较强的随机访问能力，但是相应的，插入和删除的能力就比较弱：ArrayList和Vector要求实现所用的数组的元素之间是不能有间隔的，换言之就是如果你在中间删除了一个元素，后面的都必须向前移动来补位。数组在初始化的时候要约定一个大小，所以当插入的元素个数大于当前空间的最大大小时，就需要申请新的内存空间、创建新的数组并将现有数据拷贝过去（ArrayList在内存不够时默认是扩展1.5倍，Vector是默认扩展1倍）

LinkedList是利用链表实现的，那么相应的，它的增删代价比较小，但是随机访问的能力就弱了。

• ArrayList 【重点】
  • 数组结构实现，必须要连续空间，查询快、增删慢
  • jdk1.2版本，运行效率快、线程不安全
• Vector
  • 数组结构实现，查询快、增删慢
  • jdk1.0版本，运行效率慢、线程安全
• LinkedList
  • 双向链表结构实现，无需连续空间，增删快，查询慢

ArrayList类

ArrayList是可以动态增长和缩减的索引序列，它是基于数组实现的List类

创建对象：ArrayList<要存储元素的数据类型> 变量名 = new ArrayList<要存储元素的数据类型>();

常用方法

方法	描述
boolean add（Object obj）	将指定元素obj追加到集合的末尾
Object get（int index）	返回集合中指定位置上的元素
int size（）	返回集合中的元素个数
boolean add（int index, Object obj）	将指定元素obj插入到集合中指定的位置
Object remove（int index）	从集合中删除指定index处的元素，返回该元素
void clear（）	清空集合中所有元素
Object set（int index, Object obj）	用指定元素obj替代集合中指定位置上的元素

【演示】

package com.gather.arraylist;

import java.util.ArrayList;

public class Demo01 {
    public static void main(String[] args) {
        ArrayList arraylist = new ArrayList();
        arraylist.add(10);
        arraylist.add(20);
        arraylist.add(30);
        arraylist.add(0, 40);// 在第0位添加元素40
        System.out.println("元素个数：" + arraylist.size());// 返回集合元素个数
        System.out.println(arraylist);
        System.out.println("第0位元素：" + arraylist.get(0));// 获取第0位元素
        System.out.println("删除的元素为：" + arraylist.remove(2));// 删除第2位元素，并返回该元素
        arraylist.set(1, 50);// 用50代替第1位元素
        System.out.println(arraylist);
    }
}
执行结果：
元素个数：4
[40, 10, 20, 30]
第0位元素：40
删除的元素为：20
[40, 50, 30]

重写equals()和hashCode()方法

package com.gather.arraylist;


public class Student {
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    @Override// 重写equals方法
    public boolean equals(Object o) {
        if (this == o) {// 1，比较两个引用的对象是否为同一个
            return true;
        }
        if (o == null) {// 2.判断该对象是否为null
            return false;
        }
        if (this.getClass() != o.getClass()) {// 3.判断两个引用指向的实际对象类型是否一致,即new的类是否一致
            return false;
        }
        if (o instanceof Student) {// 4.判断对象o是否是Student类的实例或者是Student类的子类实例
            Student s = (Student) o;// 若不是Student类的实例，则强制转换
            if (this.name == s.getName() && this.age == s.getAge()) {// 依次比较各个属性值是否相等
                return true;
            }
        }
        return false;
    }

    @Override// 重写hashCode方法
    public int hashCode() {
        int result = 17;
        result = 31 * result + (this.name == null ? 0 : this.name.hashCode());
        result = 31 * result + age;
        return result;
    }

    @Override// 重写toString方法
    public String toString() {
        return "[" + this.name + "," + this.age + "]";
    }
}

package com.gather.arraylist;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;

public class Demo02 {
    public static void main(String[] args) {
        Student s1 = new Student("刘德华", 20);
        Student s2 = new Student("郭富城", 23);
        Student s3 = new Student("张学友", 18);
        Student s4 = new Student("刘德华", 20);
        ArrayList alt = new ArrayList();
        alt.add(s1);
        alt.add(s2);
        alt.add(0, s3);
        /*
        s1和s4是不同的对象,但是它们的属性内容是一样的
        重写了equals和hashCode方法后，其哈希值相等
         */
        System.out.println(s1.equals(s4));
        System.out.println(s1.hashCode());
        System.out.println(s4.hashCode());
        /*
        使用Iterator迭代
         */
        System.out.println("------Iterator------");
        Iterator it = alt.iterator();
        while (it.hasNext()) {
            Student s = (Student) it.next();
            System.out.println(s.toString());
        }
        alt.remove(new Student("张学友", 18));
        /*
        使用ListIterator迭代
         */
        System.out.println("------ListIterator------");
        ListIterator lit = alt.listIterator();
        while (lit.hasNext()) {
            Student s = (Student) lit.next();
            System.out.println(s.toString());
        }
    }
}
执行结果：
true
650312502
650312502
------Iterator------
[张学友,18]
[刘德华,20]
[郭富城,23]
------ListIterator------
[刘德华,20]
[郭富城,23]

java 如何重写equal 和hashcode方法

ArrayList内存分配

• 如果没有向集合中添加任何元素时，容量0
• 添加一个元素后，容量为10
• 当插入的元素个数大于当前空间的最大大小时，就需要申请新的内存空间、创建新的数组并将现有数据拷贝过去,容量为15
• 接着每次扩容是原来的1.5倍

Vector类

Vector类实现了可扩展的对象数组。 像数组一样，它包含可以使用整数索引访问的组件。 但是， Vector的大小可以根据需要增长或缩小，以适应在创建Vector之后添加和删除项目。

常用方法

方法	描述
void addElement(Object obj)	将obj插入向量的尾部
void setElementAt(Object obj,int index)	将index处的对象设置成obj，原来的对象将被覆盖
void removeElement(Object obj)	从向量中删除obj
void removeElementAt(int index)	删除index所指的地方的对象
void removeAllElement()	删除向量所有的对象
public E firstElement()	获取向量对象中的首个obj
public E lastElement()	获取向量对象的最后一个obj

Enumeration接口

方法	描述
boolean hasMoreElements()	测试此枚举是否包含更多元素
E nextElement()	如果此枚举对象至少有一个要提供的元素，则返回此枚举的下一个元素

addElement()方法、setElementAt()方法、removeElement()方法、removeElementAt()方法

【演示】

package com.gather.vecotr;

import java.util.Vector;

public class Demo01 {
    public static void main(String[] args) {
        Vector vector = new Vector();
        Integer integer = new Integer(56);
        vector.add(integer);// 在尾部添加56
        vector.add(new Integer(10));// 在尾部添加10
        vector.addElement(new Integer(20));// 在尾部添加20
        vector.addElement(new Integer(30));// 在尾部添加30
        vector.setElementAt(new Integer(88), 0);// 将第0位元素替换为88
        vector.removeElement(integer);// 删除56
        vector.removeElementAt(2);// 删除第2位元素
    }
}

firstElement()方法、lastElement()方法

【演示】

package com.gather.vecotr;

import java.util.Vector;

public class Demo02 {
    public static void main(String[] args) {
        Vector vector = new Vector();
        vector.add("张三");
        vector.add("李四");
        vector.add("王五");
        System.out.println(vector.firstElement());// 返回第一个元素
        System.out.println(vector.lastElement());// 返回最后一个元素
        /*
        回顾：contains()方法、clear()方法、isEmpty()方法
         */
        System.out.println(vector.contains("张三"));
        vector.clear();
        System.out.println(vector.isEmpty());
    }
}
执行结果：
张三
王五
true
true

集合元素遍历（Eunmeration）

Vector中元素也可用for循环，增强for，Iterator、ListIterator遍历

【补充方法】

public Enumeration elements(); 从索引 0 开始列举向量中所有元素。该方法返回一个列举（ Enumeration ）对象。

【演示】

package com.gather.vecotr;

import java.util.Enumeration;
import java.util.Vector;

public class Demo03 {
    public static void main(String[] args) {
        Vector vector = new Vector();
        vector.addElement(new Character('A'));
        vector.addElement('B');// 集合中添加数据会自动装箱
        vector.addElement('C');
        vector.addElement('D');
        Enumeration enumeration = vector.elements();
        while (enumeration.hasMoreElements()) {
            Character c = (Character) enumeration.nextElement();
            System.out.println(c);
        }
    }
}
执行结果：
A
B
C
D

LinkedList类

LinkedList也是List接口的实现类，与ArrayList不同之处是采用的存储结构不同，ArrayList的数据结构为线性表，而LinkedList数据结构是链表。链表数据结构的特点是每个元素分配的空间不必连续、插入和删除元素时速度非常快、但访问元素的速度较慢。

常用方法

方法	描述
void addFirst(E e)	在该列表开头插入指定的元素
void addLast(E e)	将指定的元素追加到此列表的末尾
E getFirst()	返回此列表中的第一个元素
E getLast()	返回此列表中的最后一个元素
E removeFirst()	从此列表中删除并返回第一个元素
E removeLast()	从此列表中删除并返回最后一个元素

【演示】

package com.gather.linkedlist;

import java.util.LinkedList;

public class Demo01 {
    public static void main(String[] args) {
        LinkedList linkedList = new LinkedList();
        linkedList.add("猪八戒");
        linkedList.add(0, "孙悟空");
        linkedList.addFirst("唐僧");// 在列表开头添加"唐僧"
        linkedList.addLast("沙僧");// 在列表末尾添加"沙僧"，与add()方法功能相同
        System.out.println("第一个元素："+linkedList.getFirst());
        System.out.println("最后一个元素："+linkedList.getLast());
        System.out.println("删除第一个元素："+linkedList.removeFirst());
        System.out.println("删除最后一个元素："+linkedList.removeLast());
    }
}
执行结果：
第一个元素：唐僧
最后一个元素：沙僧
删除第一个元素：唐僧
删除最后一个元素：沙僧

集合元素遍历

package com.gather.linkedlist;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.ListIterator;

public class Demo02 {
    public static void main(String[] args) {
        LinkedList linkedList = new LinkedList();
        linkedList.add('B');
        linkedList.add('C');
        linkedList.addFirst('A');
        linkedList.addLast('D');
        /*
        1.利用for循环遍历
         */
        for (int i = 0; i < linkedList.size(); i++) {
            System.out.println(linkedList.get(i));
        }
        /*
        2.利用增强for遍历
         */
        for (Object o : linkedList) {
            Character c = (Character) o;
            System.out.println(c);
        }
        /*
        3.利用Iterator迭代器遍历
         */
        Iterator it = linkedList.iterator();
        while (it.hasNext()) {
            Character c = (Character) it.next();
            System.out.println(c);
        }
        /*
        4.利用ListIterator列表迭代器遍历
         */
        ListIterator lit = linkedList.listIterator();
        while (lit.hasNext()) {// 正序遍历
            Character c = (Character) lit.next();
            System.out.println(c);
        }
        while (lit.hasPrevious()) {// 逆序遍历（正序遍历结束后指针刚好指向最后一个元素）
            Character c = (Character) lit.previous();
            System.out.println(c);
        }
    }
}

ArryaList与LinkedList的区别

• ArrayList：必须开辟连续空间，查询快,增删慢

  Arraylist：底层是基于动态数组，根据下表随机访问数组元素的效率高，向数组尾部添加元素的效率高；但是，删除数组中的数据以及向数组中间添加数据效率低，因为需要移动数组。例如最坏的情况是删除第一个数组元素，则需要将第2至第n个数组元素各向前移动一位。而之所以称为动态数组，是因为Arraylist在数组元素若超过其容量，Arraylist可以进行扩容（针对JDK1.8 数组扩容后的容量是扩容前的1.5倍）

• LinkedList：无需开辟连续空间，查询慢,增删快

  Linkedlist基于链表的动态数组，数据添加删除效率高，只需要改变指针指向即可，但是访问数据的平均效率低，需要对链表进行遍历

  注：LinkedList实现原理