Java List接口的ArrayList和LinkedList的区别

List 接口

ArrayList 和 LinkedList 区别

ArrayList : 数组实现

数组实现 特点 : 查询快 增删慢(参照与LinkedList)

查询 : 直接使用角标查询

增删 : 需要把要添加的元素的位置 后面的元素 全部移动一位

LinkedList : 链表实现

链表实现 特点 : 查询慢 增删快(参照与ArrayList)

查询 : 判断离头进还是尾近 然后从头或尾 一个一个查找 找到为止

增删 : 将要插入的元素的地址保存 后面的元素 不用进行任何的改动

---

    /**
     * List常用方法
     */
    public static void fun1() {
        List list = new ArrayList();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
            // 使用list中添加方法 add(int index, Object obj)
            // 添加的角标 就是后面元素 所在位置 不能越界
            list.add(4, "x");
            System.out.println(list);
            // 通过角标 获取对应的元素
            Object object = list.get(2);
            System.out.println(object);
            // 通过get方法进行遍历
            for (int i = 0; i < list.size(); i++) {
                System.out.println(list.get(i));
            }
            // set方法(不要越界)
            list.set(4, "z");
        System.out.println(list);
        // 根据角标删除 (返回的是 被删除的元素)
        Object remove = list.remove(3);
        System.out.println(remove);
        System.out.println(list);
    }

    /**
     * 并发修改异常
     */
    public static void fun3() {
        /*
         * 集合中添加 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);
    }

    public static void fun4() {
        /*
         * 集合中添加 a b c d
         * 遍历集合 如果有 b 就添加一个"oh~yes"
         * (使用迭代器完成)
         */
        // 解决并发修改
        // 思路 : 让迭代器去完成 添加元素
        List list = new ArrayList();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        // 取出list特有的迭代器
        ListIterator listIterator = list.listIterator();
        while (listIterator.hasNext()) {
            if (listIterator.next().equals("b")) {
                // 让迭代器 向集合中 添加元素
                listIterator.add("Oh~Yes");
            }
        }
        System.out.println(list);
        // 注意 : 在迭代器中进行对集合的添加或删除 要使用迭代器中的方法
        //       不能直接使用集合去操作
    }

    public static void fun5() {
        // vector (使用数组来实现 已经被ArrayList 替代)
        // 创建一个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());
        }
    }

    public static void fun6() {
        /*
         * 利用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());
        }
        // 逆向
        // 判断前一个元素有没有
        while (listIterator.hasPrevious()) {
            // 获取前一个元素
            System.out.println(listIterator.previous());
        }
    }

        // linkedList
        LinkedList linkedList = new LinkedList();
        // 使用addfrist方法添加
        /*
        linkedList.addFirst("a");
        linkedList.addFirst("b");
        linkedList.addFirst("c");
        linkedList.addFirst("d");
        */
        linkedList.addLast("a");
        linkedList.addLast("b");
        linkedList.addLast("c");
        System.out.println(linkedList);
        // 获取头尾元素
        System.out.println(linkedList.getFirst());
        System.out.println(linkedList.getLast());


    }

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

    /**
     * ArrayList的去重
     */
    public static void fun2() {
        /*
         * 创建一个ArrayList集合
         * 添加a,a,a,b,b,b,c,c,c
         * 去除重复
         */
        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 arrayList2 = new ArrayList();
        // 遍历老数组 取出每一个元素 看是不是 存在于 新数组中
        // 获取老数组的迭代器
        Iterator iterator = arrayList.iterator();
        while (iterator.hasNext()) {
            // 判断 老数组中的元素 是否存在于新数组中
            // 如果存在 不添加到新数组中
            // 如果不存在 就添加
            // 不能调用两次 next()方法
            Object next = iterator.next();
            if (!arrayList2.contains(next)) {
                // 将元素添加到新数组中
                arrayList2.add(next);
            }

        }
        System.out.println(arrayList2);
    }

        /*
         * 创建一个ArrayList
         * 保存6个学生
         * 去除重复的学生 
         */
        ArrayList list = new ArrayList();
        // 这六个学生地址 都不一样 所以不是同一个对象
        // 我想 去重 根据对象的名字和年龄去重
        // 如果名字 和 年龄一样 咱们就认为 两个对象重复了 只保留一个
        list.add(new Student("鹏鹏", 18));
        list.add(new Student("鹏鹏", 18));
        list.add(new Student("水水", 17));
        list.add(new Student("水水", 17));
        list.add(new Student("茜茜", 16));
        list.add(new Student("茜茜", 16));
        ArrayList newlist = new ArrayList();
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            Object next = iterator.next();
            Student student = (Student)next;
            if (!newlist.contains(student)) {
                newlist.add(student);
            }

        }
        // 打印数组
        for (Object object : newlist) {
            Student student = (Student)object;
            System.out.println(student);
        }
        // 为什么同样思路不行 ? 如何解决 ? 
        // 写的去重这个思路 依赖contains这个方法


    }