Java中的List、ArrayList、LinkedList接口常用方法

List

    List是一个接口

    ArrayList 和 LinkedList 区别:

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

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

    什么时候用ArrayList?
    查询多 就用ArrayList
    什么时候用LinkedList?
    增删多 就使用LinkedList

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,"e");
        System.out.println(list);
        //输出的是 a, b, c, d, e

        //通过角标获取对应的元素
        Object object = list.get(3);
        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(4);
        System.out.println(remove);
        System.out.println(list);
    }

删除时 要注意的

    public static void fun2() {
        List list = new ArrayList();
        list.add(111);// 进行自动装箱
        list.add(222);
        list.add(333);
        //删除111元素
        //list.remove(0);
        //这里删除的时候 系统没给你 自动装箱 就按数字传入的方法
        ..所以调用 是按角标删除的方法 所以越界
        //如果你非要使用按元素删除 需要手动装箱
        list.remove(Integrt.valueOff(111));

        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
        //如果使用迭代器遍历 那么长度必须是固定
        //获取迭代器
        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() {
    //思路: 让迭代器去完成 添加元素
        List list = new ArrayList();
            list.add("a");
            list.add("b");
            list.add("c");
            list.add("d");
        ListIterator listIterator = list.listIterator();
        while(listIterator.hasNext()){
            if(listIterator.next().equals("b")){
                //让迭代器 向集合中 添加元素
                listIteratoe.add("oh~yes");
            }
        }
    System.out.println(list);
    }

vector

    public static void fun5() {
        //Vector jkd1.2 (使用数组来实现 已经被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());
        }

        //逆向
        //hasPrevious 判断前一个元素有没有
        while(lisIterator.hasPrevious()){
            System.out.println(listIterator.previous());
        }
    }

ArrayList去除重复元素

    public static void fun7() {
        /*
         * 创建一个集合
         * 添加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);
    }

    重新创一个Student类 
    有姓名 年龄
    要写构造方法 set/get方法 重写toString方法

        /*
         * 创建一个ArrayList
         * 保存6个学生
         * 去除重复学生
         */
        ArrayList List = new ArrayList();
        //这6个学生地址都不一样 所以不是同一个对象
        //要想去重复 根据对象的名字和年龄
        //如果名字和年龄一样 就认为两个对象 重复了

        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 list2 = new ArrayList();

        Iterator iterator = List.iterator;
        while(iterator.hasNext()){
            Object next = iterator.next();
            //强转student
            Student student = (Student)next;
            //contains方法 在系统里是判断相同地址的 才算包含
            //而系统中contains方法的核心是equals方法
            //所以需要重写Student类中的equals方法
            if(List2.contains(student)){
                list2.add(student);
            }
        }

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

    重写的equals方法:
        @Override
    public boolean equals(Object obj) {
        //原来系统比较的是地址
        //现在比较地址已经不能满足的我需求了
        //我需要的时 不看地址 只看 姓名和年龄
        //姓名和年龄 同时 相同 就认为是 同一个对象

        //把传进来的Object类型的对象 obj
        //转换成Student类型
        Student student = (Student)obj;
        //判断姓名和年龄 同时相同
        return this.name.equals(student.getName() &&
        this.age == student.getAge());
    }

LinkedList

    LinkedList linkedList = new LinkedList();
        //使用addfirst方法 添加
        /*
        linkedList.addFirst("a");
        linkedList.addFirst("b");
        linkedList.addFirst("c");
        linkedList.addFirst("d");
        */
        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());

LinkedList模拟栈结构

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

    队列结构 和 栈结构
    栈结构的特点: 先入的 后厨
    队列结构的特点: 先进先出
                                                                              Day.15