杰神之Java集合中的List的一些方法

List

• List 接口
  List接口是一个有序的 Collection，使用此接口能够精确的控制每个元素插入的位置，能够通过索引
  (元素在List中位置，类似于数组的下标)来访问List中的元素，第一个元素的索引为 0，而且允许有相同的元素。
  List 接口实例存储的是有序的，可以重复的元素。
  List和数组类似，可以动态增长，根据实际存储的数据的长度自动增长List的长度。
  查找元素效率高，插入删除效率低，因为会引起其他元素位置改变
• <实现类有ArrayList,LinkedList,Vector> 。
• ArrayList 和 LinkedList 的区别
  ArrayList:数组实现
  数组实现特点:查询快,增删慢(参照 LinkedList)
  查询:直接使用角标查询
  增删:需要把要添加的元素的位置,后面的元素全部移动一位
  LinkedList:链表实现
  链表实现特点:查询慢,增删快
  查询:判断离头近还是尾近,然后从头或尾,一个个查找,找到为止
  增删:将要插入/移除的元素的地址保存/删除,后面的元素不用进行任何操作
• 数组查询和链表查询的区别
  

ArrayList 一些方法代码举例:

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(4);
        System.out.println(object);
        // 通过get方法进行遍历
//      for (int i = 0; i < list.size(); i++) {
//          Object object1 = list.get(i);
//          System.out.println(object1);
//      }
        // set方法 不要越界
        list.set(1, "z");
        System.out.println(list);
        // 根据角标删除 remove 
        //返回的是被删除的元素
        Object remove = list.remove(3);
        System.out.println(remove);
        System.out.println(list);

        List li =new ArrayList();
        li.add(111);// 自动装箱
        li.add(222);
        li.add(333);
        // 删除 111 元素
        //list.remove(0);
        li.remove((Integer)111);    //系统不会自动装箱 就按数字传入方法 所有按角标删除的方法调用的 所以越界 Integer.valueOf(i) 如果要使用按元素删除需要手动装箱

        System.out.println(li);

在昨天的博客中提到了使用迭代器(Iterator)遍历数组 上面ArrayList中也提供了get方法 也可利用For循环进行遍历. 那么问题来了,如果我想在集合中添加一串字符应该如何实现呢?使用迭代器遍历添加?

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()) {
            String string = list.toString();
            if (iterator.next().equals("b")) {
                // 这时发生的异常 ConcurrentModificationException 
                // 并发修改异常
                // add  相当于修改集合长度
                // 注意:在迭代器遍历的时候 不要直接使用集合做操作
                list.add("oh");     
            }
        }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()) {
            if (listIterator.next().equals("b")) {
                listIterator.add("Oh~yes");
            }
        }System.out.println(list);
        // 注意! 在迭代器中 进行对集合的添加或删除 要使用 迭代器的方法 不能直接使用集合来操作

vector类(现被arrayList 取代)

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());
        }
        /*
 * 创建一个集合 添加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()) {
            Object next = iterator.next();
            if (!arrayList2.contains(next)) {
                arrayList2.add(next);
            }
        }System.out.println(arrayList2);
/*
 * 创建一个集合 添加学生信息
 * 去除重复
 * 根据上一题思路 应用到这题中 打印确失败了 这是为什么呢?
 */
ArrayList list = new ArrayList();
        list.add(new Student("james", 18));
        list.add(new Student("james", 18));
        list.add(new Student("TOM", 19));
        list.add(new Student("TOM", 19));
        list.add(new Student("Jellry", 18));
        list.add(new Student("Jellry", 18));
        ArrayList list1 = new ArrayList();
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
                Object next = iterator.next();
                Student student = (Student)next;
            if (!list1.contains(student)) {
                list1.add(student);
            }
        }
        for (Object object : list1) {
            Student student = (Student)object;
            System.out.println(student);
        }

队列和栈

队列的特点:先进先出
栈的特点:先进后出

使用 LinkedList 模拟栈结构
private static void fun1() {
    LinkedList linkedList = new LinkedList();
    // 添加元素A,B,C,D模拟进栈
    linkedList.addLast("A");
    linkedList.addLast("B");
    linkedList.addLast("C");
    linkedList.addLast("D");
    System.out.println(linkedList);
    // 模拟出栈
    // 每次删之前查看一下这个集合是否为空的
    while (!linkedList.isEmpty()) {
        linkedList.removeLast();
        System.out.println(linkedList);
    }
}
ArrayList 去重
public static void fun2() {
    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");
    System.out.println(arrayList);
    // 创建个新数组
    ArrayList arrayList1 = new ArrayList();
    // 遍历原数组,取出每一个元素,比对是否存在于新数组中,不存在则放入,存在就放弃
    // 原数组迭代器
    Iterator iterator = arrayList.iterator();
    while (iterator.hasNext()) {
        // 判断原数组中元素是否存在于新数组中
        // 不存在就添加入新数组中,否则放弃
        Object next = iterator.next();// 不能调用两次 next() 方法
        if (!arrayList1.contains(next)) {
            // 将元素添加到新数组中
            arrayList1.add(next);
        }
    }
    System.out.println(arrayList1);
}
去除重复的学生
public static void fun3() {
    ArrayList arrayList = new ArrayList();
    // 六个学生的地址都不一样,所以不是同一个对象
    arrayList.add(new Student("鹏鹏", 18));
    arrayList.add(new Student("鹏鹏", 18));
    arrayList.add(new Student("水水", 17));
    arrayList.add(new Student("水水", 17));
    arrayList.add(new Student("茜茜", 16));
    arrayList.add(new Student("茜茜", 16));
    Iterator iterator = arrayList.iterator();
    ArrayList arrayList2 = new ArrayList();
    while (iterator.hasNext()) {
        Object next = iterator.next();
        Student student = (Student)next;
        if (!arrayList2.contains(student)) {
            arrayList2.add(student);
        }
    }
    for (Object object : arrayList2) {
        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 "[姓名:" + name + ", 年龄:" + age + "]";
    }

    // 重写 equals 方法
    @Override
    public boolean equals(Object obj) {
        // 比较的是地址
        // return super.equals(obj);
        // 现在需求比对姓名和年龄
        Student student = (Student)obj;
        return this.name.equals(student.getName()) && this.age == student.getAge();
    }
}