List系列集合

特点：有序、可重复、有索引

• ArrayList：有序、可重复、有索引
• LinkedList：有序、可重复、有索引

List集合的特有方法

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

代码演示：

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

public class ListTest1 {
    public static void main(String[] args) {
        // 1.创建一个ArrayList集合对象(有序、可重复、有索引)
        List<String> list = new ArrayList<>();  //一行经典代码,多态写法
        list.add("愚者");
        list.add("正义");
        list.add("倒吊人");
        list.add("太阳");
        System.out.println(list);   //[愚者, 正义, 倒吊人, 太阳]
        //2.public void add(int index，E element):在某个索引位置插入元素。
        list.add(2,"魔术师");  //在索引位置为2的地方插入元素
        System.out.println(list);   //[愚者, 正义, 魔术师, 倒吊人, 太阳]
        //3.public E remove(int index):根据索引删除元素,返回被删除元素
        String name = list.remove(3);   //删除索引为3的元素并返回
        System.out.println(list);   //[愚者, 正义, 魔术师, 太阳]
        System.out.println(name);   //倒吊人
        // 4.public E get(int index):返回集合中指定位置的元素。
        String name2 = list.get(3);     //返回索引为3的元素
        System.out.println(list);   //[愚者, 正义, 魔术师, 太阳]
        System.out.println(name2);  //太阳
        //5.public E set(int index,E element): 修改索引位置处的元素,修改成功后，会返回原来的数据
        String name3 = list.set(3,"隐者");    //修改索引为3的元素的内容,原内容返回
        System.out.println(name3);  //太阳
        System.out.println(list);   //[愚者, 正义, 魔术师, 隐者]
    }
}

运行结果：

List集合的遍历方式

1. for循环(因为List集合有索引)
2. 迭代器
3. 增强for循环
4. Lambda表达式

代码演示：

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

public class ListTest2 {
    public static void main(String[] args) {
        // 1.创建一个ArrayList集合对象(有序、可重复、有索引)
        List<String> list = new ArrayList<>();  //一行经典代码,多态写法
        list.add("愚者");
        list.add("正义");
        list.add("倒吊人");
        list.add("太阳");
        System.out.println(list);   //[愚者, 正义, 倒吊人, 太阳]
        //(1)for循环
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));   //愚者 正义 倒吊人 太阳
        }
        System.out.println("-------------------------------------");
        //(2)迭代器
        Iterator<String> iterator = list.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());    //愚者 正义 倒吊人 太阳
        }
        System.out.println("-------------------------------------");
        //(3)增强for循环()
        for (String s : list) {
            System.out.println(s);  //愚者 正义 倒吊人 太阳
        }
        System.out.println("-------------------------------------");
        //(4)JDK 1.8开始之后的Lambda表达式
        list.forEach(System.out::println);  //愚者 正义 倒吊人 太阳
    }
}

运行结果：

ArrayList集合的底层原理

ArrayList集合与LinkedList集合底层采用的数据结构不同，应用场景不同

• 数据结构：存储、组织数据的方式

ArrayList集合的底层原理

ArrayList集合是基于数组实现的

• 数组：内存中的一块连续区域，把该区域分成若干个相等的小区域，每个区域都有自己的索引，每个区域都存一个数据
• 数组的基本特点：
  查询速度快（注意，是根据索引查询数据快）
  删除效率低：可能需要把后面很多数据进行前移
  添加效率极低：可能需要把后面很多的数据后移，再添加元素；或者也可能需要进行数组的扩容
• 总结：查询快，增删慢

Arraylist集合的底层原理：

• 利用无参构造器创建的集合，会在底层创建一个默认长度为0的数组
• 添加第一个元素时，底层会创建一个新的长度为10的数组
• 存满时，会扩容1.5倍
• 如果一次添加多个元素，1.5倍还放不下，则新创建数组的长度以实际为准

ArrayList集合适合的应用场景

1、ArrayLis集合t适合:根据索引查询数据比如根据随机索引取数据:(高效)!或者数据量不是很大时!
2、ArrayList集合不适合:数据量大的同时又要频繁的进行增删操作!

LinkedList集合的底层原理

LinkedList集合是基于双链表实现的

什么是链表？

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

链表的特点1:查询慢，无论查询哪个数据都要从头开始找
链表的特点2:链表增删相对快

双链表：在记录下一个结点的基础上，也记录了上一个结点的位置

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

LinkedList新增了:很多首尾操作的特有方法

LinkedList集合适合的应用场景

• LinkedList的应用场景之一:可以用来设计队列（先进先出，后进后出），只是在首尾增删元素,用Linkecllist来实现很合适!

代码演示：

import java.util.LinkedList;

public class ListTest3 {
    public static void main(String[] args) {
        LinkedList<String> queue = new LinkedList<>();
        //入队
        queue.addLast("one");
        queue.addLast("two");
        queue.addLast("three");
        queue.addLast("four");
        System.out.println(queue);  //[one, two, three, four]
        //出队
        System.out.println(queue.removeFirst());    //one
        System.out.println(queue.removeFirst());    //two
        System.out.println(queue.removeFirst());    //three
        System.out.println(queue);  //[four]
    }
}

• LinkedList的应用场景之二:可以用来设计栈（后进先出，先进后出），只是在首部增删元素,用Linkecllist来实现很合适!

代码演示：

import java.util.LinkedList;

public class ListTes4 {
    public static void main(String[] args) {
        LinkedList<String> stack = new LinkedList<>();
        //压栈push
        stack.push("第一颗子弹");
        stack.push("第二颗子弹");
        stack.push("第三颗子弹");
        stack.push("第四颗子弹");
        System.out.println(stack);  //[第四颗子弹, 第三颗子弹, 第二颗子弹, 第一颗子弹]
        //出栈pop
        System.out.println(stack.pop());    //第四颗子弹
        System.out.println(stack.pop());    //第三颗子弹
        System.out.println(stack.pop());    //第二颗子弹
        System.out.println(stack);  //[第一颗子弹]
    }
}