List：Arraylist、vector、LinkedList

一、List(导包)

还是用ArrayList子类多态继承使用。

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

public class L1 {
    public static void main(String[] args) {
        List list = new ArrayList();
   }
}

·1、特点（继承自Collection接口）

    （1）List集合中的元素是有序的（存储和取出顺序一致） 1，2，3，4，5  --->  1,2,3,4,5
    （2）List集合包含了索引的概念
    （3）List集合中的元素是可以重复的 1，1，2，3，4，4，5

2、方法

    1、添加功能：
        void add(int index, Object element) 将指定的元素插入此列表中的指定位置（可选操作）范围（index < 0 || index > size()可以等于size()）
    2、删除功能：
        Object remove(int index) 删除该列表中指定位置的元素（可选操作）。
    3、获取功能：
        Object get(int index) 返回此列表中指定位置的元素。
    4、修改功能：
        Object set(int index, Object element) 用指定的元素（可选操作）替换此列表中指定位置的元素。

public class L1 {
    public static void main(String[] args) {
        List list = new ArrayList();
        //添加元素到集合中
        list.add("hello");
        list.add("world");
        list.add("java");
        System.out.println(list);

        list.add(3,"yes");
        System.out.println(list);

        list.remove(3);
        System.out.println(list);

        System.out.println(list.get(0));

        System.out.println(list.set(0,"yes"));
        System.out.println(list);

    }
}
[hello, world, java]
[hello, world, java, yes]
[hello, world, java]
hello
hello
[yes, world, java]

    5、List集合特有的迭代器
        ListIterator listIterator() 返回列表中的列表迭代器（按适当的顺序）；由于ListIterator继承自Iterator接口，所以内部一定有hasNext()和next()方法

       listlterator特有的方法：Object previous() 返回列表中的上一个元素，并向后移动光标位置。

                                                     1、该方法是获取集合中前一个元素
                                                     2、该方法获取元素的指针与next()获取元素的指针是同一个

                                             boolean hasPrevious()  判断上一个位置是否有元素，如果有元素返回true，如果没有元素，返回false。

public class ListDemo3 {
    public static void main(String[] args) {
        //1、创建List集合对象
        List list = new ArrayList();

        //2、添加元素到集合中
        list.add("hello");
        list.add("world");
        list.add("java");
        list.add("bigdata");

        //3、遍历
        ListIterator listIterator = list.listIterator();
        while (listIterator.hasNext()) {
            String s = (String) listIterator.next();
            System.out.println(s + ",字符串的长度为：" + s.length());
        }
      //倒序输出
        while (listIterator.hasPrevious()){
            Object previous = listIterator.previous();
            System.out.println(previous);
        }
    }
}

3、遍历

List集合遍历的方式： 1、调用toArray()方法，转成数组遍历

                                    2、迭代器遍历

                                    3、size()与get()方法结合使用遍历

public class L2 {
    public static void main(String[] args) {
        List list = new ArrayList();

        //2、创建学生对象
        Student2 s1 = new Student2("王宇", 18);
        Student2 s2 = new Student2("明旺", 19);
        Student2 s3 = new Student2("周家祥", 20);
        Student2 s4 = new Student2("张保桂", 17);

        //3、将学生对象添加到集合中
        list.add(s1);
        list.add(s2);
        list.add(s3);
        list.add(s4);

        //a:转成数组遍历
        Object[] objects=list.toArray();
        for(int i=0;i<objects.length;i++){
            Student2 s=(Student2) objects[i];
            System.out.println(s.getName()+s.getAge());
        }
        System.out.println("=============================");
        //b:迭代器遍历
        Iterator iterator=list.iterator();
        while(iterator.hasNext()){
            Student2 s=(Student2) iterator.next();
            System.out.println(s.getName()+s.getAge());
        }
        System.out.println("=============================");
        //c:get()和size()方法结合遍历(这是List集合特有的遍历方式，因为有索引的概念)
        for(int i=0;i<list.size();i++){
            Student2 s=(Student2) list.get(i);
            System.out.println(s.getName()+s.getAge());
        }
    }
}

4、注意

迭代器遍历

 Iterator iterator = list.iterator();
        while (iterator.hasNext()){
            Object next = iterator.next();
            String s = (String) next;
            if("bigdata".equals(s)){
                list.add("yes");
            }
        }
报错
原因：迭代器是依赖于集合而存在的，在遍历迭代器中的元素的时候，当我们判断成功后，往集合中添加一个元素，
但是呢这时候，迭代器并不知道已经添加了元素，所以就报错了。
简单描述：在迭代器遍历的时候，不能通过集合去修改元素

解决办法

（1）迭代器遍历，迭代器修改(Iterator中没有add()方法，但list特有的ListIterator中有add()方法)

ListIterator listIterator = list.listIterator();
        while (listIterator.hasNext()){
            Object next = listIterator.next();
            String s = (String) next;
            if("bigdata".equals(s)){
                listIterator.add("yes"); //在bigdata后面添加，因为此时指针正好指到这里
            }
        }

（2）集合遍历，集合修改（get()和size()）

for(int i=0;i<list.size();i++){
            String s = (String) list.get(i);
            if("bigdata".equals(s)){
                list.add("yes"); //在集合末尾添加
            }
        }

二、ArrayList

1、概述：

                  底层数据结构是数组，查询快，增删慢，线程不安全，效率高。

2、练习

使用ArrayList存储字符串并遍历（如果字符串有重复的需要去除）
public class ArrayListDemo1 {
    public static void main(String[] args) {
        //创建集合对象
        ArrayList list = new ArrayList();

        //向集合中添加字符串元素
        list.add("hello");
        list.add("world");
        list.add("java");
        list.add("hello");
        list.add("spark");
        list.add("java");
        list.add("world");

        System.out.println("去重之前的集合为：" + list);

        //创建一个新的集合保存去重后的元素
        ArrayList list2 = new ArrayList();

        //遍历旧的集合
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            String s = (String) iterator.next();
//获取到元素之后，拿着这个元素去新集合中查找，如果找到说明重复，就不添加，反之添加到新集合中
            if (!list2.contains(s)) {
                list2.add(s);
            }
        }
        System.out.println("去重后的集合为：" + list2);
    }
}

注意：contains方法底层调用的是equals方法，String类中重写了equals方法，其他类如果没有重写equals方法则比较的是地址值。

三、Vector

1、概述

                  底层数据结构是数组，查询快，增删慢，线程安全，效率低

2、方法

public void addElement(Object obj)
    将元素添加到集合的末尾  效果上和add()一样
public Object elementAt(int index)
    获取指定索引处的元素    get(int index)
public Enumeration elements()
    返回此向量的组件的枚举。（可以看成迭代器去使用）

Enumeration elements = vector.elements();
        while (elements.hasMoreElements()) {
            Object o1 = elements.nextElement();
            String s = (String) o1;
            System.out.println(s);
        }

四、LinkedList

1、概述

               底层数据结构是链表，查询慢，增删快，线程不安全，效率高。

2、方法

1、添加功能：
    public void addFirst(Object e) 在集合的开头添加元素
    addLast(Object e) 在结合末尾添加元素，等同于add()方法
2、获取功能：
    public Object getFirst() 获取集合中的第一个元素
    getLast()  获取集合中的最后一个元素
3、删除功能：
    public Object removeFirst()  从集合中删除第一个元素并返回
    public Object removeLast()   从集合中删除最后一个元素并返回