List集合

集合

概述

集合是一种容器，但我们把数组作为容器时，会发现数组一旦定义，其长度无法更改，不利于我们对容器中的元素进行增删改。所以Java给我们提供了另外一种容器，可以很方便的去操作容器中的元素，这个容器我们叫做集合。

集合的分类

数组和集合的区别

1. 数组长度是固定的，集合长度是可变的
2. 数组只能存储同一种数据类型，集合可以存储多种数据类型
3. 数组既能存基本数据类型，也能存引用数据类型，集合只能存引用数据类型

Collection接口

常用方法

方法	功能
boolean add(E e)	添加指定元素，返回值代表是否添加成功
boolean addAll(Collection<? extends E> c)	添加指定集合中的所有元素
void clear()	移除所有元素
boolean contains(Object o)	判断集合中是否包含指定元素
boolean containsAll(Collection<?> c)	判断集合中是否包含指定集合的所有元素
boolean isEmpty()	判断集合是否为空集合
boolean remove(Object o)	移除集合中的制定元素
boolean removeAll(Collection<?> c)	移除集合中与指定集合的交集元素
boolean retainAll(Collection<?> c)	仅保留集合中与指定集合的交集元素
int size()	返回集合的元素数量
Object[] toArray()	将集合转换为数组

集合的遍历

迭代器遍历

我们可以通过Collection接口中的Iterator<E> iterator()方法，得到可对collection进行迭代的迭代器，用来遍历集合。
遍历需要通过运用迭代器中的方法：

方法	功能
boolean hasNext()	判断是否还有元素可以迭代
E next()	返回迭代的下一个元素

• 示例：遍历Integer类型集合

public class 迭代器遍历 {
    public static void main(String[] args) {
        Collection<Integer> integers = new ArrayList<>();
        integers.add(10); integers.add(20); integers.add(30);
        integers.add(40); integers.add(50); integers.add(60);
        Iterator<Integer> iterator = integers.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

for循环遍历

• 普通for循环遍历

通过collection子类中的方法E get(int index)，用for循环索引并返回索引对应的元素来遍历集合。

public class For循环遍历 {
    public static void main(String[] args) {
        Collection<Integer> integers = new ArrayList<>();
        integers.add(10); 
        integers.add(20); 
        integers.add(30);
        integers.add(40); 
        integers.add(50); 
        integers.add(60);
        ArrayList arrayList= (ArrayList) integers;
        for (int i = 0; i < arrayList.size(); i++) {
            System.out.println(arrayList.get(i));
        }
    }
}

• 增强for循环遍历

public class 增强For遍历 {
    public static void main(String[] args) {
        Collection<Integer> integers = new ArrayList<>();
        integers.add(10);
        integers.add(20);
        integers.add(30);
        integers.add(40);
        integers.add(50);
        integers.add(60);
        for (Integer integer : integers) {
            System.out.println(integer);
        }
    }
}

两种方法结果是一样的：

List类

List集合的特点是元素有序，允许重复元素

常用特有方法

方法	功能
void add(String item, int index)	在指定索引处添加元素
void remove(int position)	移除指定索引的元素

List集合的遍历

遍历List集合既可以用遍历Collection的三个方法，还可通过List集合专属的迭代器，也就是方法listIterator<E> listIterator()（列表迭代器）：

public class 列表迭代器 {
    public static void main(String[] args) {
        List<Integer> integers = new ArrayList<>();
        integers.add(10);
        integers.add(20);
        integers.add(30);
        integers.add(40);
        integers.add(50);
        integers.add(60);
        ListIterator<Integer> integerListIterator = integers.listIterator();
        while (integerListIterator.hasNext()){
            System.out.println(integerListIterator.next());
        }
    }
}

列表迭代器还有一个特有功能，可一反向遍历集合，通过方法boolean hasPrevious()和E previous()（注意：反向遍历前需要用next方法将指针移到最后一个元素）：

public class Test {
    public static void main(String[] args) {
        List<Integer> integers = new ArrayList<>();
        integers.add(10);
        integers.add(20);
        integers.add(30);
        integers.add(40);
        integers.add(50);
        integers.add(60);
        ListIterator<Integer> integerListIterator = integers.listIterator();
        while (integerListIterator.hasNext()){
            integerListIterator.next();
        }
        while (integerListIterator.hasPrevious()){
            System.out.println(integerListIterator.previous());
        }
    }
}

List的三个子类的特点

• ArrayList:
  底层数据结构是数组，查询快，增删慢。
  线程不安全，效率高。
• Vector:
  底层数据结构是数组，查询快，增删慢。
  线程安全，效率低。
• LinkedList:
  底层数据结构是链表，查询慢，增删快。
  线程不安全，效率高。