JavaSE学习笔记(十六)—— List集合

一、List接口概述

1.1 List概述

  有序(存储和取出的元素一致)的 collection(也称为序列)。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引(在列表中的位置)访问元素,并搜索列表中的元素。与 set 不同,列表通常允许重复的元素。

1.2 List案例

【List集合存储字符串并遍历】

public class ListDemo {
    public static void main(String[] args) {
        // 创建集合对象
        List list = new ArrayList();

        // 创建字符串并添加字符串
        list.add("hello");
        list.add("world");
        list.add("java");

        // 遍历集合
        Iterator it = list.iterator();
        while (it.hasNext()) {
            String s = (String) it.next();
            System.out.println(s);
        }
    }
}

【存储自定义对象并遍历】

public class ListDemo {
    public static void main(String[] args) {
        // 创建集合对象
        List list = new ArrayList();

        // 创建学生对象
        Student s1 = new Student("白骨精", 30);
        Student s2 = new Student("蜘蛛精", 40);
        Student s3 = new Student("观音姐姐", 22);

        // 把学生对象添加到集合对象中
        list.add(s1);
        list.add(s2);
        list.add(s3);

        // 遍历
        Iterator it = list.iterator();
        while (it.hasNext()) {
            Student s = (Student) it.next();
            System.out.println(s.getName() + "---" + s.getAge());
        }
    }
}

二、List的特有功能

2.1 基本功能

【添加功能】

  void add(int index,Object element):在指定位置添加元素

【获取功能】

  Object get(int index):获取指定位置的元素

【列表迭代器】

  ListIterator listIterator():List集合特有的迭代器

【删除功能】

  Object remove(int index):根据索引删除元素,返回被删除的元素

【修改功能

  Object set(int index,Object element):根据索引修改元素,返回被修饰的元素

public class ListDemo {
    public static void main(String[] args) {
        // 创建集合对象
        List list = new ArrayList();

        // 添加元素
        list.add("hello");
        list.add("world");
        list.add("java");

        // void add(int index,Object element):在指定位置添加元素
        // list.add(1, "android");//没有问题
        // IndexOutOfBoundsException
        // list.add(11, "javaee");//有问题
        // list.add(3, "javaee"); //没有问题
        // list.add(4, "javaee"); //有问题

        // Object get(int index):获取指定位置的元素
        // System.out.println("get:" + list.get(1));
        // IndexOutOfBoundsException
        // System.out.println("get:" + list.get(11));

        // Object remove(int index):根据索引删除元素,返回被删除的元素
        // System.out.println("remove:" + list.remove(1));
        // IndexOutOfBoundsException
        // System.out.println("remove:" + list.remove(11));

        // Object set(int index,Object element):根据索引修改元素,返回被修饰的元素
        System.out.println("set:" + list.set(1, "javaee"));

        System.out.println("list:" + list);
    }
}

2.2 遍历功能

【使用普通for循环]

  List集合的特有遍历功能:size()和get()方法结合使用

public class ListDemo {
    public static void main(String[] args) {
        // 创建集合对象
        List list = new ArrayList();

        // 添加元素
        list.add("hello");
        list.add("world");
        list.add("java");

        for (int x = 0; x < list.size(); x++) {
            String s = (String) list.get(x);
            System.out.println(s);
        }
    }
}

  存储自定义对象并遍历,用普通for循环。(size()和get()结合)

public class ListDemo3 {
    public static void main(String[] args) {
        // 创建集合对象
        List list = new ArrayList();

        // 创建学生对象
        Student s1 = new Student("林黛玉", 18);
        Student s2 = new Student("刘姥姥", 88);
        Student s3 = new Student("王熙凤", 38);

        // 把学生添加到集合中
        list.add(s1);
        list.add(s2);
        list.add(s3);

        // 遍历
        // 迭代器遍历
        Iterator it = list.iterator();
        while (it.hasNext()) {
            Student s = (Student) it.next();
            System.out.println(s.getName() + "---" + s.getAge());
        }
        System.out.println("--------");

        // 普通for循环
        for (int x = 0; x < list.size(); x++) {
            Student s = (Student) list.get(x);
            System.out.println(s.getName() + "---" + s.getAge());
        }
    }
}

【使用列表迭代器】

  ListIterator listIterator():List集合特有的迭代器。该迭代器继承了Iterator迭代器,所以,就可以直接使用hasNext()和next()方法。

  特有功能:

  • Object previous():获取上一个元素
  • boolean hasPrevious():判断是否有元素
public class ListIteratorDemo {
    public static void main(String[] args) {
        // 创建List集合对象
        List list = new ArrayList();
        list.add("hello");
        list.add("world");
        list.add("java");

        // 迭代器
        Iterator it = list.iterator();
        while (it.hasNext()) {
            String s = (String) it.next();
            System.out.println(s);
        }
        System.out.println("----------");

        // ListIterator listIterator()
        ListIterator lit = list.listIterator();
        while (lit.hasPrevious()) {
            String s = (String) lit.previous();
            System.out.println(s);
        }
    }
}

  注意:ListIterator可以实现逆向遍历,但是必须先正向遍历,才能逆向遍历,所以一般无意义,不使用。

三、List的并发修改异常

  问题:我有一个集合,如下,请问,我想判断里面有没有"world"这个元素,如果有,我就添加一个"javaee"元素,请写代码实现。

public class ListIteratorDemo {
    public static void main(String[] args) {
        // 创建List集合对象
        List list = new ArrayList();
        // 添加元素
        list.add("hello");
        list.add("world");
        list.add("java");

        // 迭代器遍历
        Iterator it = list.iterator();
        while (it.hasNext()) {
            String s = (String) it.next();
            if ("world".equals(s)) {
                list.add("javaee");
            }
        }

    }
}

  运行上述代码时,出现了这样的异常:

  

  ConcurrentModificationException:当方法检测到对象的并发修改,但不允许这种修改时,抛出此异常。

【产生的原因】

  迭代器是依赖于集合而存在的,在判断成功后,集合中新添加了元素,而迭代器却不知道,所以就报错了,这个错叫并发修改异常。
  其实这个问题描述的是:迭代器遍历元素的时候,通过集合是不能修改元素的

【解决方法】

  • 方式一:迭代器迭代元素,迭代器修改元素(元素是跟在刚才迭代的元素后面的)
    public class ListIteratorDemo {
        public static void main(String[] args) {
            // 创建List集合对象
            List list = new ArrayList();
            // 添加元素
            list.add("hello");
            list.add("world");
            list.add("java");
    
            // 方式1:迭代器迭代元素,迭代器修改元素
            // 而Iterator迭代器却没有添加功能,所以我们使用其子接口ListIterator
            ListIterator lit = list.listIterator();
            while (lit.hasNext()) {
                String s = (String) lit.next();
                if ("world".equals(s)) {
                    lit.add("javaee");
                }
            }
    
            System.out.println("list:" + list);//[hello, world, javaee, java]
        }
    }
  • 方式2:集合遍历元素,集合修改元素(元素在最后添加的)
    public class ListIteratorDemo {
        public static void main(String[] args) {
            // 创建List集合对象
            List list = new ArrayList();
            // 添加元素
            list.add("hello");
            list.add("world");
            list.add("java");
    
            // 方式2:集合遍历元素,集合修改元素(普通for)
            for (int x = 0; x < list.size(); x++) {
                String s = (String) list.get(x);
                if ("world".equals(s)) {
                    list.add("javaee");
                }
            }
    
            System.out.println("list:" + list);//[hello, world, java, javaee]
        }
    }

四、List接口的实现类

4.1 ArrayList

【ArrayList类概述】

  底层数据结构是数组,查询快,增删慢
  线程不安全,效率高

【ArrayList案例】

  存储字符串并遍历

public class ArrayListDemo {
    public static void main(String[] args) {
        // 创建集合对象
        ArrayList array = new ArrayList();

        // 创建元素对象,并添加元素
        array.add("hello");
        array.add("world");
        array.add("java");

        // 遍历
        Iterator it = array.iterator();
        while (it.hasNext()) {
            String s = (String) it.next();
            System.out.println(s);
        }

        System.out.println("-----------");

        for (int x = 0; x < array.size(); x++) {
            String s = (String) array.get(x);
            System.out.println(s);
        }
    }
}

  ArrayList存储自定义对象并遍历

public class ArrayListDemo2 {
    public static void main(String[] args) {
        // 创建集合对象
        ArrayList array = new ArrayList();

        // 创建学生对象
        Student s1 = new Student("武松", 30);
        Student s2 = new Student("鲁智深", 40);
        Student s3 = new Student("林冲", 36);
        Student s4 = new Student("杨志", 38);

        // 添加元素
        array.add(s1);
        array.add(s2);
        array.add(s3);
        array.add(s4);

        // 遍历
        Iterator it = array.iterator();
        while (it.hasNext()) {
            Student s = (Student) it.next();
            System.out.println(s.getName() + "---" + s.getAge());
        }

        System.out.println("----------------");

        for (int x = 0; x < array.size(); x++) {
            // ClassCastException 注意,千万要搞清楚类型
            // String s = (String) array.get(x);
            // System.out.println(s);

            Student s = (Student) array.get(x);
            System.out.println(s.getName() + "---" + s.getAge());
        }
    }
}

  去除集合中字符串的重复值(字符串的内容相同)

/*
 * 分析:
 *         A:创建集合对象
 *         B:添加多个字符串元素(包含内容相同的)
 *         C:创建新集合
 *         D:遍历旧集合,获取得到每一个元素
 *         E:拿这个元素到新集合去找,看有没有
 *             有:不搭理它
 *             没有:就添加到新集合
 *         F:遍历新集合
 */
public class ArrayListDemo {
    public static void main(String[] args) {
        // 创建集合对象
        ArrayList array = new ArrayList();

        // 添加多个字符串元素(包含内容相同的)
        array.add("hello");
        array.add("world");
        array.add("java");
        array.add("world");
        array.add("java");
        array.add("world");
        array.add("world");
        array.add("world");
        array.add("world");
        array.add("java");
        array.add("world");

        // 创建新集合
        ArrayList newArray = new ArrayList();

        // 遍历旧集合,获取得到每一个元素
        Iterator it = array.iterator();
        while (it.hasNext()) {
            String s = (String) it.next();

            // 拿这个元素到新集合去找,看有没有
            if (!newArray.contains(s)) {
                newArray.add(s);
            }
        }

        // 遍历新集合
        for (int x = 0; x < newArray.size(); x++) {
            String s = (String) newArray.get(x);
            System.out.println(s);
        }
    }
}

  去除集合中字符串的重复值(字符串的内容相同),要求:不能创建新的集合,就在以前的集合上做。

public class ArrayListDemo2 {
    public static void main(String[] args) {
        // 创建集合对象
        ArrayList array = new ArrayList();

        // 添加多个字符串元素(包含内容相同的)
        array.add("hello");
        array.add("world");
        array.add("java");
        array.add("world");
        array.add("java");
        array.add("world");
        array.add("world");
        array.add("world");
        array.add("world");
        array.add("java");
        array.add("world");

        // 由选择排序思想引入,我们就可以通过这种思想做这个题目
        // 拿0索引的依次和后面的比较,有就把后的干掉
        // 同理,拿1索引...
        for (int x = 0; x < array.size() - 1; x++) {
            for (int y = x + 1; y < array.size(); y++) {
                if (array.get(x).equals(array.get(y))) {
                    array.remove(y);
                    y--;
                }
            }
        }

        // 遍历集合
        Iterator it = array.iterator();
        while (it.hasNext()) {
            String s = (String) it.next();
            System.out.println(s);
        }
    }
}

  去除集合中自定义对象的重复值(对象的成员变量值都相同)

/*
 * 我们按照和字符串一样的操作,发现出问题了。
 * 为什么呢?
 *         我们必须思考哪里会出问题?
 *         通过简单的分析,我们知道问题出现在了判断上。
 *         而这个判断功能是集合自己提供的,所以我们如果想很清楚的知道它是如何判断的,就应该去看源码。
 * contains()方法的底层依赖的是equals()方法。
 * 而我们的学生类中没有equals()方法,这个时候,默认使用的是它父亲Object的equals()方法
 * Object()的equals()默认比较的是地址值,所以,它们进去了。因为new的东西,地址值都不同。
 * 按照我们自己的需求,比较成员变量的值,重写equals()即可。
 * 自动生成即可。
 */
public class ArrayListDemo3 {
    public static void main(String[] args) {
        // 创建集合对象
        ArrayList array = new ArrayList();

        // 创建学生对象
        Student s1 = new Student("林青霞", 27);
        Student s2 = new Student("林志玲", 40);
        Student s3 = new Student("凤姐", 35);
        Student s4 = new Student("芙蓉姐姐", 18);
        Student s5 = new Student("翠花", 16);
        Student s6 = new Student("林青霞", 27);
        Student s7 = new Student("林青霞", 18);

        // 添加元素
        array.add(s1);
        array.add(s2);
        array.add(s3);
        array.add(s4);
        array.add(s5);
        array.add(s6);
        array.add(s7);

        // 创建新集合
        ArrayList newArray = new ArrayList();

        // 遍历旧集合,获取得到每一个元素
        Iterator it = array.iterator();
        while (it.hasNext()) {
            Student s = (Student) it.next();

            // 拿这个元素到新集合去找,看有没有
            if (!newArray.contains(s)) {
                newArray.add(s);
            }
        }

        // 遍历新集合
        for (int x = 0; x < newArray.size(); x++) {
            Student s = (Student) newArray.get(x);
            System.out.println(s.getName() + "---" + s.getAge());
        }
    }
}

4.2 Vector

【Vector类概述】

  底层数据结构是数组,查询快,增删慢
  线程安全,效率低

  注:Vector很少用了,现在ArrayList基本上取代了Vector。

【Vector类特有功能】

  添加功能:public void addElement(Object obj) -- add()

  获取功能:

  public Object elementAt(int index)    -- get()
  public Enumeration elements()      -- Iterator iterator()
    boolean hasMoreElements()       hasNext()
    Object nextElement()             next()

public class VectorDemo {
    public static void main(String[] args) {
        // 创建集合对象
        Vector v = new Vector();

        // 添加功能
        v.addElement("hello");
        v.addElement("world");
        v.addElement("java");

        // 遍历
        for (int x = 0; x < v.size(); x++) {
            String s = (String) v.elementAt(x);
            System.out.println(s);
        }

        System.out.println("------------------");

        Enumeration en = v.elements(); // 返回的是实现类的对象
        while (en.hasMoreElements()) {
            String s = (String) en.nextElement();
            System.out.println(s);
        }
    }
}

4.3 LinkedList

【LinkedList类概述】

  底层数据结构是链表,查询慢,增删快
  线程不安全,效率高

【LinkedList类特有功能】

  A:添加功能
    public void addFirst(Object e)
    public void addLast(Object e)
  B:获取功能
    public Object getFirst()
    public Obejct getLast()
  C:删除功能
    public Object removeFirst()
    public Object removeLast()

public class LinkedListDemo {
    public static void main(String[] args) {
        // 创建集合对象
        LinkedList link = new LinkedList();

        // 添加元素
        link.add("hello");
        link.add("world");
        link.add("java");

        // public void addFirst(Object e)
        // link.addFirst("javaee");
        // public void addLast(Object e)
        // link.addLast("android");

        // public Object getFirst()
        // System.out.println("getFirst:" + link.getFirst());
        // public Obejct getLast()
        // System.out.println("getLast:" + link.getLast());

        // public Object removeFirst()
        System.out.println("removeFirst:" + link.removeFirst());
        // public Object removeLast()
        System.out.println("removeLast:" + link.removeLast());

        // 输出对象名
        System.out.println("link:" + link);
    }
}

【练习】

  请用LinkedList模拟栈数据结构的集合,并测试

  注意,题目的意思是:你自己的定义一个集合类,在这个集合类内部可以使用LinkedList模拟。

  MyStack.java

/**
 * 自定义的栈集合
 */
public class MyStack {
    private LinkedList linkedList;

    public MyStack() {
        linkedList = new LinkedList();
    }

    public void add(Object obj) {
        linkedList.addFirst(obj);
    }

    public Object get() {
        return linkedList.removeFirst();
    }

    public boolean isEmpty() {
        return linkedList.isEmpty();
    }
}

  MyStackDemo.java

/**
 * MyStack的测试
 */
public class MyStackDemo {
    public static void main(String[] args) {
        // 创建集合对象
        MyStack myStack = new MyStack();

        // 添加元素
        myStack.add("hello");
        myStack.add("world");
        myStack.add("java");

        while (!myStack.isEmpty()) {
            System.out.println(myStack.get());
        }
    }
}

五、List集合的综合练习

【题目一】

  集合的嵌套遍历

  需求:
  我们班有学生,每一个学生都是一个对象。所以我们可以使用一个集合表示我们班级的学生。ArrayList<Student>
  但是呢,我们旁边还有班级,每个班级也是一个ArrayList<Student>。
  而我现在有多个ArrayList<Student>。也要用集合存储,怎么办呢?
  就是这个样子的:ArrayList<ArrayList<Student>>

public class ArrayListDemo {
    public static void main(String[] args) {
        // 创建大集合
        ArrayList<ArrayList<Student>> bigArrayList = new ArrayList<>();

        // 创建第一个班级的学生集合
        ArrayList<Student> firstArrayList = new ArrayList<>();
        // 创建学生
        Student s1 = new Student("唐僧", 30);
        Student s2 = new Student("孙悟空", 29);
        Student s3 = new Student("猪八戒", 28);
        Student s4 = new Student("沙僧", 27);
        Student s5 = new Student("白龙马", 26);
        // 学生进班
        firstArrayList.add(s1);
        firstArrayList.add(s2);
        firstArrayList.add(s3);
        firstArrayList.add(s4);
        firstArrayList.add(s5);
        // 把第一个班级存储到学生系统中
        bigArrayList.add(firstArrayList);

        // 创建第二个班级的学生集合
        ArrayList<Student> secondArrayList = new ArrayList<Student>();
        // 创建学生
        Student s11 = new Student("诸葛亮", 30);
        Student s22 = new Student("司马懿", 28);
        Student s33 = new Student("周瑜", 26);
        // 学生进班
        secondArrayList.add(s11);
        secondArrayList.add(s22);
        secondArrayList.add(s33);
        // 把第二个班级存储到学生系统中
        bigArrayList.add(secondArrayList);

        // 创建第三个班级的学生集合
        ArrayList<Student> thirdArrayList = new ArrayList<Student>();
        // 创建学生
        Student s111 = new Student("宋江", 40);
        Student s222 = new Student("吴用", 35);
        Student s333 = new Student("高俅", 30);
        Student s444 = new Student("李师师", 22);
        // 学生进班
        thirdArrayList.add(s111);
        thirdArrayList.add(s222);
        thirdArrayList.add(s333);
        thirdArrayList.add(s444);
        // 把第三个班级存储到学生系统中
        bigArrayList.add(thirdArrayList);

        // 遍历集合
        for (ArrayList<Student> students : bigArrayList) {
            for (Student student : students) {
                System.out.println(student.getName() + "---" + student.getAge());
            }
        }
    }
}

【题目二】

  获取10个1-20之间的随机数,要求不能重复

/**
 * 用数组实现,但是数组的长度是固定的,长度不好确定。所以我们使用集合实现。
 * 分析:
 *         A:创建产生随机数的对象
 *         B:创建一个存储随机数的集合。
 *         C:定义一个统计变量。从0开始。
 *         D:判断统计遍历是否小于10
 *             是:先产生一个随机数,判断该随机数在集合中是否存在。
 *                     如果不存在:就添加,统计变量++。
 *                     如果存在:就不搭理它。
 *             否:不搭理它
 *         E:遍历集合
 */
public class RandomDemo {
    public static void main(String[] args) {
        // 创建产生随机数的对象
        Random random = new Random();

        // 创建一个存储随机数的集合
        ArrayList<Integer> arrayList = new ArrayList<>();

        // 定义一个统计变量。从0开始。
        int count = 0;

        // 判断统计遍历是否小于10
        while (count < 10) {
            //先产生一个随机数
            int number = random.nextInt(20) + 1;

            //判断该随机数在集合中是否存在。
            if (!arrayList.contains(number)) {
                //如果不存在:就添加,统计变量++。
                arrayList.add(number);
                count++;
            }
        }

        // 遍历集合
        for (Integer i : arrayList) {
            System.out.println(i);
        }
    }
}

【题目三】

  键盘录入多个数据,以0结束,要求在控制台输出这多个数据中的最大值

/**
 * 分析:
 *         A:创建键盘录入数据对象
 *         B:键盘录入多个数据,我们不知道多少个,所以用集合存储
 *         C:以0结束,这个简单,只要键盘录入的数据是0,我就不继续录入数据了
 *         D:把集合转成数组
 *         E:对数组排序
 *         F:获取该数组中的最大索引的值
 */
public class ArrayListDemo {
    public static void main(String[] args) {
        // 创建键盘录入数据对象
        Scanner sc = new Scanner(System.in);

        // 键盘录入多个数据,我们不知道多少个,所以用集合存储
        ArrayList<Integer> arrayList = new ArrayList<>();

        // 以0结束,这个简单,只要键盘录入的数据是0,我就不继续录入数据了
        while (true) {
            System.out.println("请输入数据:");
            int number = sc.nextInt();
            if (number != 0) {
                arrayList.add(number);
            } else {
                break;
            }
        }

        // 把集合转成数组
        // public <T> T[] toArray(T[] a)
        Integer[] i = new Integer[arrayList.size()];
        arrayList.toArray(i);

        // 对数组进行排序
        Arrays.sort(i);

        // 获取该数组中的最大索引的值
        System.out.println("数组是:" + Arrays.toString(i) + "最大值是:" + i[i.length - 1]);
    }
}

 

转载于:https://www.cnblogs.com/yft-javaNotes/p/10856110.html

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值