集合框架之ArrayList和LinkedList的区别-阿里云开发者社区

前言：

学集合框架就是了解容器的数据结构（增删改查）

1. ArrayList数据结构

1.1 ArrayList的特点

首先ArrayList底层是一个数组，顾名（Array）思义。如数组的特点有序根据下标进行排序，元素可重复。

如图所示：数组可根据下标找到指定元素，并按加入顺序进行排序。

实战论证：

public static void main(String[] args) {
    List list = new ArrayList();
    // 添加三个内容
    list.add("ikun");
    list.add("小黑子");
    list.add("针食泥鸭");
    System.out.println("目前集合容器中的元素：" + list);
    // 查找第二个内容
    System.out.println(list.get(1));
  }
    //打印结果：小黑子

1.2 ArrayList 的三种遍历方式

public static void main(String[] args) {
    List list = new ArrayList();
    // 添加三个内容
    list.add("ikun");
    list.add("小黑子");
    list.add("针食泥鸭");
    // 1.fori
    for (int i = 0; i < list.size(); i++) {
      System.out.println(list.get(i));
    }
    // 2.foreach
    for (Object o : list) {
      System.out.println(o);
    }
    // 3.Iterator（迭代器）
    Iterator it = list.iterator();
    while (it.hasNext()) {
      System.out.println(it.next());
    }
  }

2. LinkedList数据结构

2.1 LinkedList的特点

如图所示： LinkedList是一种链表

该特点：根据节点依次往下查找元素，因此查询效率比ArrayList低。因为该集合是无序的，删除该集合中的某一元素并不会对其他元素造成变化，所以在新增和删除的时候比ArryList要快

3. 什么是堆栈与队列？

都是一种数据结构

3.1 堆栈的特点：先进后出

如图所示：假如三个跳水运动员依次跳入池水（容器）里，而最后跳入水中的要比前面的人先出去（不要反驳我的例子，我也感觉有点怪诞😥）

3.2 队列的特点：先进先出

如图所示：例如有一条隧道，一行人从里面走过，第一个进去的人肯定也是第一出去（排除一个是老人，残疾，后面的人不准跑）防止有杠精🙅

3.3 用LinkedList完成一个堆栈容器和队列容器

package com.ycxw;
import java.util.LinkedList;
/**
 * 用LinkedList完成一个堆栈容器和队列容器
 * 
 * @author justz
 *
 */
public class Text_02 {
  public static void main(String[] args) {
    LinkedList list = new LinkedList();
    list.add("ikun");
    list.add("小黑子");
    list.add("姬霓太美");
    // 实例化堆栈对象
    dui z = new dui(list);
    // 调用弹栈方法打印输出
    System.out.println("堆栈容器：");
    System.out.println(z.pop());
    System.out.println(z.pop());
    System.out.println(z.pop());
    // 实例化队列对象
    lie l = new lie(list);
    System.out.println("队列容器：");
    System.out.println(l.duilie());
    System.out.println(l.duilie());
    System.out.println(l.duilie());
  }
}
// 定义一个堆栈对象
class dui {
  private LinkedList ll;
  public dui(LinkedList ll) {
    super();
    this.ll = ll;
  }
  // 定义一个弹栈方法pop
  // 当这个方法被调用时，后存进的内容要先输出，先存入的内容后输出
  public Object pop() {
    return ll.removeLast();
  }
}
// 定义一个队列对象
class lie {
  private LinkedList ll;
  public lie(LinkedList ll) {
    super();
    this.ll = ll;
  }
  // 当这个方法被调用时，先存进的内容要先输出，后存入的内容后输出
  public Object duilie() {
    return ll.remove();
  }
}

运行结果：

4. 增长因子论证

4.1 list集合存储过程

以ArrayList为例以数组方式进行存储，数组长度是不可变的，默认是10；

public class Text_03 {
  public static void main(String[] args) throws Exception {
    ArrayList list = new ArrayList(); //修改ArrayList(50) 默认长度就为50
    list.add("1");
    elementDataLength(list);
  }
  // 该方法是获取底层数组的长度
  private static void elementDataLength(ArrayList l) throws Exception {
    Field f = l.getClass().getDeclaredField("elementData");
    f.setAccessible(true);
    Object[] o = (Object[]) f.get(l);
    System.out.println("当前集合底层数组容量长度为：" + o.length);
  }
}

4.2 list的扩容因子

package com.ycxw;
import java.lang.reflect.Field;
import java.util.ArrayList;
public class Text_03 {
  public static void main(String[] args) throws Exception {
    ArrayList list = new ArrayList();
    for (int i = 0; i < 50; i++) {
      list.add(i);
      System.out.print("当前集合长度"+i+"\r");
      elementDataLength(list);
    }
  }
  // 该方法是获取底层数组的长度
  private static void elementDataLength(ArrayList l) throws Exception {
    Field f = l.getClass().getDeclaredField("elementData");
    f.setAccessible(true);
    Object[] o = (Object[]) f.get(l);
    System.out.println("当前集合底层数组容量长度为：" + o.length);
  }
}

运行结果：

由此结论：

当添加内容超过默认数组长度会自动扩容，增长因子为 ‘原容量的0.5倍 + 1++’（每扩容一次叠加1,如扩容第二次就加2），因此我们可对其进行调优，根据需求修改默认底层数组长度减少扩容次数，从而提高效率。

ArrayList list = new ArrayList(50); 可根据需求定义默认长度，超过该长度才进行扩容

5. 集合框架ArrayList中的重复元素去重及其底层原理

5.1 字符串去重

public class Text_04 {
  public static void main(String[] args) {
    List list = new ArrayList();
    list.add("a");
    list.add("b");
    list.add("c");
    System.out.println("目前集合容器中的元素：" + list);
    if (!list.contains("b")) {
      list.add("b");
    }
    System.out.println("目前集合容器中的元素：" + list);
  }
}

5.2 对象去重

必须要重写equals方法，由此结论list底层对象去重原理就是：存储对象的euqlas方法返回值决定；

package com.ycxw;
import java.util.ArrayList;
import java.util.List;
public class Text_04 {
  public static void main(String[] args) {
    List list = new ArrayList();
    list.add(new ikun("小黑子"));
    list.add(new ikun("真爱粉"));
    list.add(new ikun("纯路人"));
    list.add(new ikun("纯路人"));
    System.out.println("目前集合容器中的元素：" + list);
    // 新建一个集合保存遍历旧集合的内容
    List newlist = new ArrayList();
    for (Object object : list) {
      // 判断不包含相同就添加
      if (!newlist.contains(object)) {
        newlist.add(object);
      }
    }
    System.out.println("去重后集合容器中的元素：" + newlist);
  }
}
// 定义一个实体对象
class ikun {
  private String name;
  public String getName() {
    return name;
  }
  public void setName(String name) {
    this.name = name;
  }
  public ikun(String name) {
    super();
    this.name = name;
  }
  @Override
  public int hashCode() {
    final int prime = 31;
    int result = 1;
    result = prime * result + ((name == null) ? 0 : name.hashCode());
    return result;
  }
  @Override
  public boolean equals(Object obj) {
    if (this == obj)
      return true;
    if (obj == null)
      return false;
    if (getClass() != obj.getClass())
      return false;
    ikun other = (ikun) obj;
    if (name == null) {
      if (other.name != null)
        return false;
    } else if (!name.equals(other.name))
      return false;
    return true;
  }
  @Override
  public String toString() {
    return "ikun [name=" + name + "]";
  }
}

本篇到这里结束啦，感谢观看！关注我持续更新哦🫰

集合框架之ArrayList和LinkedList的区别

前言：