Java集合进阶之Collection单列集合（List）

public static void main(String[] args) {
    Collection<String> c = new ArrayList<>();

    //添加元素
    c.add("好好学习");
    c.add("天天向上");
    c.add("认真生活");

    //boolean remove(Object o); 从集合中移除指定的元素
    System.out.println(c.remove("认真生活"));

    //boolean contains(Object o);判断集合中是否存在指定的元素
    //System.out.println(c.contains("认真生活"));

    //boolean isEmpty();判断是否为空
    System.out.println(c.isEmpty());

    //void clear();清空集合中的元素
    c.clear();

    //int size();集合的长度，也就是集合的个数
    System.out.println(c.size());

    System.out.println(c);
}

遍历（迭代器）

<迭代器的介绍 >

迭代器，集合的专用遍历模式
Iterator<E> iterator()：返回此集合中元素的迭代器，通过集合的iterator()方法得到
迭代器是通过集合的iterator()方法得到的，所以我们说它是依赖于集合而存在的

//迭代器遍历
Iterator<String> it = c.iterator();

  //用while循环改进元素的判断和获取
    while (it.hasNext()) {
        String s = it.next();
        System.out.println(s);
    }

并发修改异常

出现的原因：

迭代器遍历的过程中，通过集合对象修改了集合中的元素，造成了迭代器获取元素中判断预期修改值和实际修改值

不一致，则会出现：ConcurrentModificationException。

解决的方法：

用for循环遍历，然后用集合对象做对应的操作即可。

示例代码

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

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

        //遍历集合，得到每一个元素，看有没有"world"这个元素，如果有，我就添加一个"javaee"元素，请写代码实现
//        Iterator<String> it = list.iterator();
//        while (it.hasNext()) {
//            String s = it.next();
//            if(s.equals("world")) {
//                list.add("javaee");
//            }
//        }

        for(int i=0; i<list.size(); i++) {
            String s = list.get(i);
            if(s.equals("world")) {
                list.add("javaee");
            }
        }

        //输出集合对象
        System.out.println(list);
    }
}

List集合

概述

有序集合(也称为序列)，用户可以精确控制列表中每个元素的插入位置。用户可以通过整数索引访问元素，并搜索列表中的元素
与Set集合不同，列表通常允许重复的元素

特点以及特有方法

有索引
可以存储重复元素
元素存取有序

特别提示：

由于list集合，用户是通过索引访问元素的，在进行增删改操作的时候，要注意索引越界的问题。

列表迭代器

<ListIterator介绍>

通过List集合的listIterator()方法得到，所以说它是List集合特有的迭代器
用于允许程序员沿任一方向遍历的列表迭代器，在迭代期间修改列表，并获取列表中迭代器的当前位置

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

        //添加元素
        list.add("Hello");
        list.add("World");
        list.add("Java");

       /* //通过List集合的listIterator()方法得到 列表迭代器
        ListIterator<String> lit = list.listIterator();
        while(lit.hasNext()) {
            String s = lit.next();
            System.out.println(s);
        }
        System.out.println("**************************");
        //boolean hasPrevious();相反遍历
        while(lit.hasPrevious()) {
            String s = lit.previous();
            System.out.println(s);
        }*/

        //获取列表迭代器
        ListIterator<String> lit = list.listIterator();
        while(lit.hasNext()) {
            String s = lit.next();
            if (s.equals("World")) {
                lit.add("Javaee");
            }
        }
        System.out.println(list);
    }
}

三种遍历方法

【1】迭代器方式，集合特有的遍历方式

【2】普通for，带有索引的遍历方式

【3】增强for，最方便的遍历方式

这里给出一个视频中讲解的存储学习对象的案例，用以上三种方式遍历集合。

案例需求：

创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合（三种方式）

学生类

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        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;
    }
}

测试类

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

        //创建学生对象
        Student s1 = new Student("林青霞", 30);
        Student s2 = new Student("张曼玉", 35);
        Student s3 = new Student("王祖贤", 33);

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

        //迭代器：集合特有的遍历方式
        Iterator<Student> it = array.iterator();
        while (it.hasNext()) {
            Student s = it.next();
            System.out.println(s.getName() + "," + s.getAge());
        }
        System.out.println("--------");

        //普通for：带有索引的遍历方式
        for(int i=0; i<array.size(); i++) {
            Student s = array.get(i);
            System.out.println(s.getName() + "," + s.getAge());
        }
        System.out.println("--------");

        //增强for：最方便的遍历方式
        for(Student s : array) {
            System.out.println(s.getName() + "," + s.getAge());
        }
    }
}

LinkedList集合的特有功能

示例代码

public class LinkedListTest {
    public static void main(String[] args) {
        //创建集合对象
        LinkedList<String> linkedList = new LinkedList<>();

        linkedList.add("Hello");
        linkedList.add("World");
        linkedList.add("Java");

        /*public void addFirst(E e)在该列表开头插入指定的元素
        public void addLast(E e)将指定的元素追加到此列表的末尾*/
        /*linkedList.addFirst("Javaee");
        linkedList.addLast("Javaee");*/

        /*public E getFirst()返回此列表中的第一个元素
        public E getLast()返回此列表中的最后一个元素*/
        /*System.out.println(linkedList.getFirst());
        System.out.println(linkedList.getLast());*/

        /*public E removeFirst()从此列表中删除并返回第一个元素
        public E removeLast()从此列表中删除并返回最后一个元素*/
        System.out.println(linkedList.removeFirst());
        System.out.println(linkedList.removeLast());

        System.out.println(linkedList);
    }
}

总结

1）List集合，它所有子类都具有可以存储重复元素、存取有序、三种方法都可遍历集合的特点。

2）ArrayList集合，底层是数组结构实现，查询快、增删慢；LinkedList集合，底层是链表结构实现，查询慢、增删快。

今天的Collection单列集合大致内容分享到这就结束了，下期再会，友友们！！

Java集合进阶之Collection单列集合（List）

前言

集合概述

Collection集合

概述

常用方法