Java 集合之List、ArrayList、LinkedList以及Vector详解

list接口

list接口中常用方法:
        List list = new ArrayList();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");

        // 使用list中添加方法 add(int index, Object obj)
        // 添加的角标就是后面元素所在的位置  不能越界
        list.add(3, "x");
        System.out.println(list);

        // 通过角标获取对应的元素
        Object object = list.get(1);
        System.out.println(object);

        // 通过get 方法 进行遍历
        for (int i = 0; i < list.size(); i++) {
            Object object2 = list.get(i);
            System.out.println(object2);
        }

        // set 方法 不要越界
        list.set(0, "z");
        System.out.println(list);

        // 根据角标删除 返回的是被删除的元素 
        Object remove = list.remove(3);
        System.out.println(remove);
        System.out.println(list);

删除时要注意的:
        List list = new ArrayList();
        list.add(111);
        list.add(222);
        list.add(333);
        // 删除 111 元素
        list.remove(0);
        // 删除时 系统没自动装箱 就按数字传入的方法
        // 调用的是 按角标删除的方法调用 所以越界
        // list.remove(111);
        // 如果非要使用按元素删除 需要手动装箱
        list.remove(Integer.valueOf(111));
        System.out.println(list);

/*
* 需求:
* 集合中添加 a b c d
* 遍历集合  如果有b 就添加一个 "oh~yes"
*/
并发修改异常:
        List list = new ArrayList();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        // 添加完4元素  这时集合长度为4
        // 如果使用迭代器遍历  那么 长度必须是固定的 4不能变
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            if (iterator.next().equals("b")) {
                // ConcurrentModificationException 发生并发修改异常
                // 注意:在迭代器遍历的时候 不要直接使用集合做操作
                // list.add("oh~yes"); 相当于修改了集合长度
            }
        }
        System.out.println(list);

解决并发修改异常:
        // 取出list特有的迭代器
        ListIterator listIterator = list.listIterator();
        while (listIterator.hasNext()) {
            if (listIterator.next().equals("b")) {
                // 让迭代器 向集合中 添加元素
                listIterator.add("oh~yes");
            }
        }
        System.out.println(list);
注意: 在迭代器中进行对集合的添加或删除 要使用迭代器中的方法,不能直接使用集合去操作

逆向:
        List list = new ArrayList();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        ListIterator listIterator = list.listIterator();
        // 正向
        while (listIterator.hasNext()) {
            System.out.println(listIterator.next());
        }
        // hasPrevious 判断有没有前一个元素
        while (listIterator.hasPrevious()) {
            System.out.println(listIterator.previous());
        }

Vector

        // 创建一个Vector集合
        Vector vector = new Vector();
        vector.addElement("a");
        vector.addElement("b");
        vector.addElement("c");
        vector.addElement("d");
        System.out.println(vector);
        // 迭代器遍历
        // 获取Vector 中的迭代器
        Enumeration elements = vector.elements();
        while (elements.hasMoreElements()) {
            // 输出元素
            System.out.println(elements.nextElement());
        }

LinkedList

        LinkedList linkedList = new LinkedList();

使用addFirst:
        linkedList.addFirst("a");
        linkedList.addFirst("b");
        linkedList.addFirst("c");
        linkedList.addFirst("d");

使用addLast:
        linkedList.addLast("a");
        linkedList.addLast("b");
        linkedList.addLast("c");
        linkedList.addLast("d");
        System.out.println(linkedList);

获取头尾元素:
        System.out.println(linkedList.getFirst());
        System.out.println(linkedList.getLast());

ArrayList 和 LinkedList 的区别

ArrayList：数组实现
数组实现 特点:查询快 增删慢(参照于LinkedList)
查询：直接使用角标查询
增删：需要把要添加的元素的位置 后面的元素 全部移动一位

LinkedList：链表实现
链表实现 特点:查询慢 增删快
查询:判断离头近 还是尾近 然后从头或尾一个一个的查找  找到位置
增删：将要插入的元素的地址保存 后面的元素 不用进行任何的改动

注意：查询多使用ArrayList,增删多 使用 LinkedList

ArrayList 和 LinkedList 的区别(图解)

队列 和 栈

栈结构特点: 先入 后出
队列结构特点:先进先出

使用LinkedList 模拟出栈:
            LinkedList list = new LinkedList();
            // 添加元素
            list.addLast("a");
            list.addLast("b");
            list.addLast("c");
            list.addLast("d");
            // 模拟出栈
            while (!list.isEmpty()) {
                Object removeLast = list.removeLast();
                System.out.println(removeLast);
            }

ArrayList 去重:
            ArrayList arrayList = new ArrayList();
            arrayList.add("a");
            arrayList.add("a");
            arrayList.add("a");
            arrayList.add("b");
            arrayList.add("b");
            arrayList.add("b");
            arrayList.add("c");
            arrayList.add("c");
            arrayList.add("c");
            ArrayList arrayList1 = new ArrayList();
            Iterator iterator = arrayList.iterator();
            while (iterator.hasNext()) {
                // 不能调用两次next
                Object next = iterator.next();
                if (!arrayList1.contains(next)) {
                    arrayList1.add(next);
                }
            }
            System.out.println(arrayList1);

/*
* 需求:
* 创建一个集合
* 保存6个学生
* 去除重复学生
*/
public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        // 这六个学生地址都不一样 所以不是同一个对象
        // 我想去重 根据对象名字和年龄去重
        // 如果名字和年龄一样 咱们就认为 两个对象重复了
        arrayList.add(new Student("pp",18));
        arrayList.add(new Student("pp",18));
        arrayList.add(new Student("shui",17));
        arrayList.add(new Student("shui",17));
        arrayList.add(new Student("xi",16));
        arrayList.add(new Student("xi",16));
        ArrayList arrayList1 = new ArrayList();
        // 获取老迭代器
        Iterator iterator = arrayList.iterator();
        while (iterator.hasNext()) {
            Object next = iterator.next();
            Student student = (Student)next;
            if(!arrayList1.contains(student)) {
                arrayList1.add(student);
            }
        }

        // 打印新数组
        for (Object object : arrayList1) {
            Student student = (Student)object;
            System.out.println(student);
        }
    }

public class Student {
    private String name;
    private int age;
    public Student() {
        super();
    }
    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + "]";
    }
    // 重写equals方法 
    @Override
    public boolean equals(Object obj) {
        // 原来系统比较的是地址
        // 现在比较地址 已经不能满足我的需求了
        // 我的需求不看地址 只看姓名和年龄
        // 姓名年龄同时相同时  就认为是一个对象

        // 把传进来的转换成Student类型
        Student student = (Student)obj;
        // 判断
        return this.name.equals(student.getName())
                && this.age == student.getAge();
    }
}