List系列集合

一:特点：有序，可重复，有索引。

Arraylist：有序，可重复，有索引。

LinkedList：有序，可重复，有索引。

底层实现不同！适用的场景不同

2.List集合的特有方法

List集合因为支持索引，所以多了很多与索引相关的方法，当然，Collection的功能List也都继承了。

add(int index, E element) 在此集合中的指定位置插入指定的元素。

remove(int index) 删除指定索引处的元素，返回被删除的元素。

set(int index,E element) 修改指定索引处的元素，返回被修改的元素。

get(int index) 返回指定索引处的元素。

3.示例：

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

public class ListTest1 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("李畅");
        list.add("彭舰航");
        list.add("卢硕");
        list.add("余航");

        list.add(3, "胡超凡");//在此集合中的指定位置插入指定的元素。

        System.out.println(list.remove(3));//删除指定索引处的元素，返回被删除的元素。

        list.set(2, "蔡建宇");//修改指定索引处的元素，返回被修改的元素。

        list.get(3);//返回指定索引处的元素。
    }
}

二:List集合支持遍历方式

1.for循环（因为List集合有索引）

2.迭代器

3.增强for循环

4.Lambda表达式

5.示例：

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

public class ListTest2 {
    public static void main(String[] args) {
        List<String> S = new ArrayList<>();
        S.add("李畅");
        S.add("彭舰航");
        S.add("卢硕");
        S.add("余航");

        // 1.使用for循环遍历集合
        for (int i = 0; i < S.size(); i++) {
            System.out.println(S.get(i));
        }
        // 2.使用迭代器遍历集合
        Iterator it = S.listIterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
        // 3.使用for增强遍历集合
        for (String s : S) {
            System.out.println(s);
        }
        // 4.使用Lambda表达式遍历集合
        S.forEach(System.out::println);
    }
}

三:ArrayList集合的底层原理

1.基于数组实现的。

2.特点：

·查询速度快（注意：是根据索引查询数据快）：查询数据通过地址值和索引定位，查询任意数据耗时相同。

·删除效率低：可能需要把后面很多的数据进行前移。

·添加效率低：可能需要把后面很多的数据后移，再添加元素；或者也可能需要进行数组的扩容。

3.详细：

one：利用无参构造器创建的集合，会在底层创建一个默认长度为0的数组。

two：添加一个元素时，底层会创建一个新的长度为10的数

组。

three：存满时，会扩容1.5倍。

four：如果一次添加多个元素，1.5倍还放不下，则新创建数组的长度以实际为准。

4.ArrayList集合适合的应用场景

·Arraylist适合：根据索引查询数据，比如根据随机索引取数据（高效）！或者数据量不是很大时！

·Arraylist不适合：数据量大的同时，又要频繁的进行增删操作！

四:LinkedList集合的底层原理

1.基于双链表实现的。

2.链表中的结点是独立的对象，在内存中是不连续的，每个结点包含数据值和下一个结点的地址。

单链表的特点1：查询慢，无论查询从哪个数据都要从头开始找

单链表的特点2：链表增删相对快

双链表的特点：查询慢，增删相对较快，但对首尾元素进行增删改查的速度是极快的。

3.LinkedList新增了：很多首尾操作的特有方法。

addFirst() 在该列表开头插入指定的元素

addLast() 将指定的元素追叫到此列表的末尾

getLast() 返回此列表的最后一个元素

getFirst() 返回此列表的第一个元素

removeFirst() 从列表中删除并返回第一个元素

removeLast() 从列表中删除并返回最后一个元素

4.示例：

import java.util.LinkedList;

public class LinkedListTest1 {
    public static void main(String[] args) {
        LinkedList<String> list = new LinkedList<>();
        list.addFirst("王凯");
        list.addLast("刘凯");
        list.getLast();
        list.getFirst();
        System.out.println(list.removeFirst());//从列表中删除并返回第一个元素
        System.out.println(list.removeLast());//从列表中删除并返回最后一个元素
    }
}

5.LinkedList的应用场景之一：可以用来设计队列（先进先出，后进后出）

import java.util.LinkedList;

public class LinkedListTest2 {
    public static void main(String[] args) {
        //设计一个队列
        LinkedList<String> queue = new LinkedList<>();
        //进队
        queue.addLast("一号");
        queue.addLast("二号");
        queue.addLast("三号");
        queue.addLast("四号");
        //出队
        System.out.println(queue.removeFirst());
        System.out.println(queue.removeFirst());
        System.out.println(queue.removeFirst());
        System.out.println(queue);

应用场景二：可以用来设计栈（先进后出，后进先出）

数据进入栈模型的过程为：压/进栈(push)

数据离开栈模型的过程为：弹/出栈(pop)

//设计一个把枪
LinkedList<String> gun = new LinkedList<>();
//装弹
gun.push("第一颗");
gun.push("第二颗");
gun.push("第三颗");
gun.push("第四颗");
//射出
gun.pop();
gun.pop();
gun.pop();
System.out.println(gun);