java之List接口（单列集合）

List接口概述

查询API我们可知：java.util.List 接口继承自 Collection 接口，是单列集合的一个重要分支，习惯性地会将实现了 List 接口的对象称为List集合。在List集合中允许出现重复的元素，所有的元素是以一种线性方式进行存储的，在程序中可以通过索引来访问集合中的指定元素。另外，List集合还有一个特点就是元素有序，即元素的存入顺序和取出顺序一致。

List接口特点：

它是一个元素存取有序的集合。例如，存元素的顺序是11、22、33。那么集合中，元素的存储就是按照11、22、33的顺序完成的）。
它是一个带有索引的集合，通过索引就可以精确的操作集合中的元素（与数组的索引是一个道理）。
集合中可以存储重复的元素，通过元素的equals方法，来比较是否为重复的元素。

List接口中常用方法

List作为Collection集合的子接口，不但继承了Collection接口中的全部方法，而且还增加了一些根据元素索引来操作集合的特有方法，如下：

public void add(int index, E element) : 将指定的元素，添加到该集合中的指定位置上。
public E get(int index) :返回集合中指定位置的元素。
public E remove(int index) : 移除列表中指定位置的元素, 返回的是被移除的元素。
public E set(int index, E element) :用指定元素替换集合中指定位置的元素,返回值的更新前的元素。

注意:
操作索引的时候,一定要防止索引越界异常

IndexOutOfBoundsException:索引越界异常,集合会报
ArrayIndexOutOfBoundsException:数组索引越界异常
StringIndexOutOfBoundsException:字符串索引越界异常

代码举例

package demo01List;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Demo01List {
    public static void main(String[] args) {
        //创建一个List集合对象,多态
        List<Integer> list = new ArrayList<>();
        //使用add方法往集合中添加元素
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        //打印集合,不是地址重写了toString
        System.out.println(list);//[1, 2, 3, 4]
        //public void add(int index, E element): 将指定的元素，添加到该集合中的指定位置上。
        //在3 和 4元素之间添加元素88
        list.add(3, 88);
        System.out.println(list);//[1, 2, 3, 88, 4]
        /*public E remove(int index): 移除列表中指定位置的元素, 返回的是被移除的元素。‘
        移除index为2的元素
        */
        System.out.println("被移除的元素：" + list.remove(2));//被移除的元素：3
        //打印集合
        System.out.println(list);//[1, 2, 88, 4]
        /*
        public E set(int index, E element):用指定元素替换集合中指定位置的元素,返回值的更新前的元素。
        把index为1的元素替换为999
         */
        System.out.println("被替换的元素：" + list.set(0, 999));
        //打印集合
        System.out.println(list);
        // List集合遍历有3种方式
        //方式1：普通for循环
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i) + " ");//999 2 88 4
        }
        System.out.println(" ");
        //方式2：迭代器遍历
        Iterator<Integer> iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.print(iterator.next() + " ");//999 2 88 4
        }
        System.out.println("     ");
        //增强for循环 建议使用
        for (Integer integer : list) {
            System.out.print(integer + " ");//999 2 88 4
        }
    }
}

List的子类

ArrayList集合

java.util.ArrayList 集合数据存储的结构是数组结构。元素增删慢，查找快，由于日常开发中使用最多的功能为查询数据、遍历数据，所以 ArrayList 是最常用的集合。许多程序员开发时非常随意地使用ArrayList完成任何需求，并不严谨，这种用法是不提倡的。

LinkedList集合

LinkedList是List的子类，List中的方法LinkedList都是可以使用。java.util.LinkedList 集合数据存储的结构是链表结构。方便元素添加、删除的集合。LinkedList是一个双向链表实现。实际开发中对一个集合元素的添加与删除经常涉及到首尾操作，而LinkedList提供了大量首尾操作的方法。常用的方法如下：

public void addFirst(E e) :将指定元素插入此列表的开头。
public void addLast(E e) :将指定元素添加到此列表的结尾。
public E getFirst() :返回此列表的第一个元素。
public E getLast() :返回此列表的最后一个元素。
public E removeFirst() :移除并返回此列表的第一个元素。
public E removeLast() :移除并返回此列表的最后一个元素。
public E pop() :从此列表所表示的堆栈处弹出一个元素。
public void push(E e) :将元素推入此列表所表示的堆栈。
public boolean isEmpty() ：如果列表不包含元素，则返回true。

代码举例：

package demo01List;

import java.util.LinkedList;

public class Demo01LinkedList {
    public static void main(String[] args) {

        //使用子类特有的方法不能使用多态
        LinkedList<String> linkedList = new LinkedList<>();
        //添加元素
        linkedList.add("张三");
        linkedList.add("张四");
        linkedList.add("张五");
        //打印集合，查看里面的元素
        System.out.println(linkedList);//[张三, 张四, 张五]
        //- public void addFirst(E e):将指定元素插入此列表的开头。public void push(E e)此方法等效于 addFirst(E)。
        linkedList.addFirst("张二");
        //   public void addLast(E e):将指定元素添加到此列表的结尾。
        linkedList.addLast("张六");
        //打印集合，查看里面的元素
        System.out.println(linkedList);//[张二, 张三, 张四, 张五, 张六]
        // - public E getFirst():返回此列表的第一个元素。集合中的元素没有改变。
        System.out.println("集合中的第一个元素是：" + linkedList.getFirst());//集合中的第一个元素是：张二
        //  - public E getLast():返回此列表的最后一个元素。集合中的元素没有改变。
        System.out.println("集合中的最后一个元素是：" + linkedList.getLast());//集合中的最后一个元素是：张六
        //打印集合，查看里面的元素
        System.out.println(linkedList);//[张二, 张三, 张四, 张五, 张六]
        // public E removeFirst():移除并返回此列表的第一个元素。public E pop():此方法相当于 removeFirst。集合中的元素已经发生改变
        System.out.println("删除的集合中的第一个元素：" + linkedList.removeFirst());//删除的集合中的第一个元素：张二
        // public E removeLast():移除并返回此列表的最后一个元素。集合中的元素已经发生改变
        System.out.println("删除的集合中的最后一个元素：" + linkedList.removeLast());//删除的集合中的最后一个元素：张六
        //打印集合，查看里面的元素
        System.out.println(linkedList);//[张三, 张四, 张五]
        //public boolean isEmpty()：如果列表不包含元素，则返回true。
        System.out.println("集合中是不包含元素:" + linkedList.isEmpty());//集合中是不包含元素:false
        //清空集合
        linkedList.clear();
        System.out.println("集合中是不包含元素:" + linkedList.isEmpty());//集合中是不包含元素:true

    }
}

Vector集合

Vector集合是最早期的集合，JDK1.0版本开始就存在

特点：

底层是的数据结构是：增长的对象数组，增删慢，查询快
从 Java 2 平台 v1.2 开始，此类改进为可以实现 List 接口，使它成为 Java Collections Framework 的成员，可以使用迭代器
Vector 是同步的，他是单线程实现的，效率慢，但是安全

JDK9对集合添加的优化

通常，我们在代码中创建一个集合（例如，List 或 Set ），并直接用一些元素填充它。实例化集合，几个 add方法调用，使得代码重复。Java 9，添加了几种集合工厂方法,更方便创建少量元素的集合、map实例。新的List、Set、Map的静态工厂方法可以更方便地创建集合的不可变实例。JDK9的新特性:List接口,Set接口,Map接口:里边增加了一个静态的方法of,可以给集合一次性添加多个元素static <E> List<E> of(E... elements)

使用前提:

当集合中存储的元素的个数已经确定了,不在改变时使用

注意:

of方法只适用于List接口,Set接口,Map接口,不适用于接接口的实现类
of方法的返回值是一个不能改变的集合,集合不能再使用add,put方法添加元素,会抛出异常
Set接口和Map接口在调用of方法的时候,不能有重复的元素,否则会抛出异常

package demo01Map;

import java.util.List;
import java.util.Map;
import java.util.Set;

public class JDK9 {
    public static void main(String[] args) {
        List<String> list = List.of("a", "b", "a", "c", "d");
        System.out.println(list);//[a, b, a, c, d]
        //list.add("w");//UnsupportedOperationException:不支持操作异常

        //Set<String> set = Set.of("a", "b", "a", "c", "d");//IllegalArgumentException:非法参数异常,有重复的元素
        Set<String> set = Set.of("a", "b", "c", "d");
        System.out.println(set);
        //set.add("w");//UnsupportedOperationException:不支持操作异常

        //Map<String, Integer> map = Map.of("张三", 18, "李四", 19, "王五", 20,"张三",19);////IllegalArgumentException:非法参数异常,有重复的元素
        Map<String, Integer> map = Map.of("张三", 18, "李四", 19, "王五", 20);
        System.out.println(map);//{王五=20, 李四=19, 张三=18}
        //map.put("赵四",30);//UnsupportedOperationException:不支持操作异常
    }
}