List系列集合

image.png

List集合特点，特有API

• 特点

  1. ArrayList、LinkedList：有序，可重复，有索引
  2. 有序：存储和取出的元素顺序一致
  3. 有索引：可以通过索引操作元素
  4. 可重复：存储的元素可以重复
  5. ArrayList底层是基于数组实现的，根据查询元素块，增删相对较慢
  6. LinkedList底层基于双链表实现的，查询元素慢，增删首位元素是相对较快的

• 特有API

  方法名称	说明
  void add(int index, E element)	在此集合中的指定位置插入指定的元素
  E remove(int index)	删指定索引处的元素，返回被删除的元素
  E set(int index, E element)	修改指定索引处的元素，返回被修改的元素
  E get(int index)	返回指定索引处的元素

• 测试代码

  package com.java.list;
  
  import java.util.ArrayList;
  import java.util.List;
  
  public class ListDemo01 {
      public static void main(String[] args) {
          // 1. 创建一个ArrayList集合对象
          List<String> list = new ArrayList<>();  // 多态的风格
          // 2. 在指定索引位置插入元素
          list.add("Java");
          list.add("Java");
          list.add("MySQL");
          list.add("MySQL");
  
          list.add(2,"Html"); // 在索引2的位置上添加元素Html
          System.out.println(list);
  
          // 3. 在指定索引位置删除元素，返回被删除元素
          System.out.println(list.remove(2));
          System.out.println(list);
  
          // 4. 根据索引获取元素
          System.out.println(list.get(2));
  
          // 5.修改指定索引位置的元素，返回修改前的数据
          System.out.println(list.set(1,"高斯林"));
  
          System.out.println(list);
      }
  }
  
  

List集合的遍历方式

List集合作为父接口Collection的实现类，拥有其三种遍历方式的同时，又因为本身拥有索引而拥有for循环

1. 迭代器
2. 增强for循环
3. Lambda表达式
4. for循环

• 测试代码

  package com.java.list;
  
  import java.util.ArrayList;
  import java.util.Iterator;
  import java.util.List;
  
  public class ListDemo02 {
      public static void main(String[] args) {
          List<String> list = new ArrayList<>();
          list.add(0, "Java");
          list.add(1, "JVM");
          list.add(2, "JDK");
          list.add(3, "JRE");
  
          // 1. for循环
          for (int i = 0; i < list.size(); i++) {
              System.out.print(list.get(i) + " ");
          }
  
          System.out.println();
  
          // 2. 迭代器
          Iterator<String> it = list.iterator();
          while (it.hasNext()) {
              System.out.print(it.next() + " ");
          }
  
          System.out.println();
  
          // 3. 增强for循环
          for (String rs : list) {
              System.out.print(rs + " ");
          }
  
          // 4. Lambda表达式
          list.forEach(System.out::println);
      }
  }
  
  

ArrayList集合的底层原理

• ArrayList底层是基于数组实现的；根据索引定位元素快，增删需要做元素的移位操作

1. 第一次创建集合并添加第一个元素的时候，在底层创建一个默认长度为10的数组
2. 往数组里面添加元素，使用size记录元素的个数同时也是下次插入元素的位置
3. 一旦元素的个数超过了10，按照1.5倍扩容，将元素重新迁移到扩容后的数组
4. 删除元素时修改其后元素下标，size减去1即可

LinkedList集合的底层原理

• LinkedList的底层数据结构是双链表，查询慢，首位操作的速度是极快的，所以多了很多首尾操作特有的API

LinkedList集合特有的功能

• 测试代码

  package com.java.list;
  
  import java.util.LinkedList;
  
  public class LinkedListDemo {
      public static void main(String[] args) {
          LinkedList<String> list = new LinkedList<>();
          // 实现栈结构
          // 压栈
          list.addFirst("1号");
          list.addFirst("2号");
          list.addFirst("3号");
          list.addFirst("4号");
          // 事实上，第一个进来的1号变成了最后一个出去的，先进后出，后进先出
  
          // 出栈
          System.out.println(list.removeFirst());
          System.out.println(list);
  
          // 实现队列
          // 入队
          LinkedList<String> list1 = new LinkedList<>();
          list1.addLast("1号");
          list1.addLast("2号");
          list1.addLast("3号");
          list1.addLast("4号");
          System.out.println(list1);
  
          // 出队
          System.out.println(list1.removeFirst());
          System.out.println(list1);
  
          // 事实上，官方提供了正确的规范化的压栈出栈操作，内部实际上是将对应API包装成一个方法对外使用
          // 压栈 addFirst() --> push()
          // 出栈 removeFirst() --> pop()
  
          // 对于队列，因为队列是先进先出，后进后出的数据结构，因此没有必要再去修改成官方的方法
  
      }
  }