Java LinkedList切片 java linkedlist api

JAVA高级应用

ArrayList 和 LinkedList的区别

ArrayList:数组实现
特点:查询快 删除慢(参照于LinkedList)
查询:直接使用角标查询
增删:需要把要添加的元素的位置 后面的元素 全部移到一位
LinkedList:链表实现
特点:查询慢 增删快
查询:判断离头近还是离尾近, 然后从头或尾 一个一个查找 找到为止
增删:将要插入的元素地址保存 后面的元素不用进行任何改动

查询多 就使用ArrayList
增删多 就使用LinkedList

工作中一般使用ArrayList

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(4,"x");
System.out.println(list); //结果:a b c d x

通过角标获取对应元素
Object object = list.get(2);
System.out.println(object);  //结果:c

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

set方法不要越界
list.set(0,"z");
System.out.println(list);  //结果:z a b c d

删除角标方法 返回的是 被删除的元素
Object object2 = list.remove(3);
System.out.println(object2);  //结果:c
System.out.println(list);  //结果:z a b d

删除元素

List list = new ArrayList();
list.add(111);   //进行自动装箱
list.add(222);
list.add(333);
//删除111元素
Object object = list.remove(0);
System.out.println(object);  //结果:111

list.remove(Integer.valueOf(111));
这里删除的时候 系统没给你自动装箱 就按数字传入的方法
这里调用的是 按角标删除的方法 所以越界
如果非要使用按元素删除 需要手动装箱
System.out.println(list); //结果:222 333

添加元素 – 错误示例:发生并发修改异常

/*
         * 集合中添加 a b c d
         * 遍历集合 如果有b就 添加一个"oh~yes"
         * 使用迭代器完成
         */
public static void fun3(){
    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()){
发生异常 ConcurrentModificationException
并发修改异常
相当于修改了集合的长度
注意:在迭代器遍历的时候 不要直接使用集合做操作
        if(iterator.Next().equals("b")){
            list.add("oh-yes");
        }
    }
    System.out.println(list);
}

添加元素 – 解决并发修改异常

public static void fun3(){
//思路:让迭代器listIterator去完成添加元素
//而不是由list去完成
    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")){
        //  让迭代器向集合中添加元素
            listIterator.add("oh-yes");
        }
    }
    System.out.println(list);
    //  注意:在迭代器中进行添加或者删除 要使用迭代器中得方法
    //  不能直接使用集合去操作
}

逆向遍历元素

public static void fun6(){}
    List list = new ArrayList();
    List.add("a");
    List.add("b");
    List.add("c");
    List.add("d");

    ListIterators listIterator = list.listIterator();
    //  判断是否有前一个元素
    while(listIterator.hasPrevious()){
    //  获取前一个元素
        System.out.println(listIterator.previous());
    }
}

结果:无法输出  因为迭代器中有一个指针,指在最开始的位置,而不是末尾位置,
所有hasPrevious()的值为null,要想输出元素,需先正向遍历,将指针移到末尾,之
后向前遍历,便可打印出全部元素

添加元素 获取元素

LinkedList linkedList = new LinkedList();
linkedList.addFirst("a");
linkedList.addFirst("b");
linkedList.addLast("c");
linkedList.addLast("d");

System.out.println(linkedList);
System.out.println(linkedList.getFirst());
System.out.println(linkedList.getLast());

vector简介

//  vector 1.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 enumeration = vector.elements();
while(enumation.hasMoreElements()){
    //输出元素
    System.out.println(enumation.nextElement);
}

linkedList模拟栈结构

public static void fun1(){
    LinkedList listedList = new LinkedList();
    linkedList.addLast("a");
    linkedList.addLast("b");
    linkedLast.addLast("c");

    while(!linkedList.isEmpty()){
        System.out.println(linkedList.removeLast());
    }
}

ArrayList去重

private static void fun2(){
    LinkedList linkedList = new LinkedList();
    linkedList.add("a");
    linkedList.add("a");
    linkedList.add("a");

    linkedList.add("b");
    linkedList.add("b");
    linkedList.add("b");

    linkedList.add("c");
    linkedList.add("c");
    linkedList.add("c");

    Iterator iterator = linkedList.iterator();
    LinkedList linkedList1 = new LinkedList();
    while(iterator.hasNext()){
    //  判断老数组中得元素 是否存在新数组中
    //  如果存在 不添加到新数组中
    //  如果不存在 就添加
    //  不能两次调用next方法
        Object object = iterator.Next();
        if(!linkedList.contains(object)){
            linkedList.add(object);
        }
    }
    System.out.println(newList);
}

ArrayList去除重复对象

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 newArray = new ArrayList();
        java.util.Iterator iterator = list.iterator();

        while(iterator.hasNext()) {
            //  判断 老数组中得元素 是否存在新数组中
            //  如果存在 不添加到新数组中
            //  如果不存在 就添加
            //  不能两次调用next方法
            Object next = iterator.next();
             if(!newArray.contains(next)) {
                 newArray.add(next);
             }
        }
        //  为什么同样的思路不行?如何解决
        //  写的去重这个思路 依赖contains这个方法


        for(Object object : newArray) {
            Student student = (Student)object;
            System.out.println(student.getName());
            System.out.println(student.getAge());
        }
        //  为什么同样思路不行?
    }

    @Override
    public boolean equals(Object obj) {
        // TODO Auto-generated method stub
        //  原来系统比较地址
        //  现在比较地址 已经不能满足我的需求了
        //  我的需求 不看地址 只看姓名和年龄
        //  姓名和年龄同时相同 就认为是对的

        //把传进来的转换成Student类型
        Student student = (Student)obj;

        return this.name.equals(student.getName()) 
                &&  this.age == student.getAge();
    }