ArrayList与顺序表

最新推荐文章于 2024-09-14 10:04:17 发布

2401_83526138

最新推荐文章于 2024-09-14 10:04:17 发布

阅读量721

点赞数 18

文章标签：数据结构算法

本文链接：https://blog.csdn.net/2401_83526138/article/details/140057746

版权

注：此博文为本人学习过程中总结的笔记

1.线性表

线性表是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表，链表，栈，队列...

线性表在逻辑上是线性结构，也就是一条连续的直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。

2.顺序表

顺序表是一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。

2.1.常见的接口

public class SeqList {
    private int[] array;
    private int size;
    // 默认构造方法
    SeqList(){ 

    }
    // 将顺序表的底层容量设置为initcapacity
    SeqList(int initcapacity){ 

    }
    // 新增元素,默认在数组最后新增
    public void add(int data) { 

    }
    // 在 pos 位置新增元素
    public void add(int pos, int data) {

    }
    // 判定是否包含某个元素
    public boolean contains(int toFind) { 
        return true;
    }
    // 查找某个元素对应的位置
    public int indexOf(int toFind) { 
        return -1;
    }
    // 获取 pos 位置的元素
    public int get(int pos) { 
        return -1; 
    }
    // 给 pos 位置的元素设为 value
    public void set(int pos, int value) { 

    }
    // 删除第一次出现的关键字key
    public void remove(int toRemove) { 

    }
    // 获取顺序表长度
    public int size() { 
    return 0; 
    }
    // 清空顺序表
    public void clear() { 

    }
}

3.ArrayList

在集合框架中，ArrrayList是一个普通的类，实现了List接口，具体框架图如下

说明：

1.ArrayList是以泛型反式实现的，使用时必须要先实例化

2.ArrayList实现了RandomAcess接口，表明ArrayList支持随机访问

3.ArrayList实现了Cloneable接口，表明ArrayList是可以clone的

4.ArrayList实现了Serializable接口，表明ArrayList是支持序列化的

5.和Vector不同，ArrayList不是线程安全的，在单线程下可以使用，在多线程下可以使用Vector或者CopyOnWriteArrayList

6.ArrayList底层是一段连续的空间，并且可以动态扩容，是一个动态类型的顺序表

3.1.ArrayList的遍历

ArrayList可以使用for循环和foreach循环进行遍历。

public Test {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        for(int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        for(int x:list) {
            System.out.println(x);
        }
    }
}

3.2.ArrayList的构造

方法:

ArrayList() // 无参构造

ArrayList(Collection<? extends E>c) // 利用其他 Collection 构建 ArrayList

ArrayList(int initialCapacity) // 指定顺序表初始容量

public static void main(String[] args) {
    //ArrayList创建，推荐写法
    //构造一个空的列表
    List<Integer> list1 = new ArrayList<>();
    
    //构造一个具有10个容量的列表
    List<Integer> list2 = new ArrayList<>(10);
    list2.add(1);
    list2.add(2);
    list2.add(3);

    //list3构造好之后，与list中的元素一致
    ArrayList<Integer> list3 = new ArrayList<>(list2);
}

3.3.ArrayList的常见方法

boolean add(E e) // 尾插 e

void add(int index, E element) // 将 e 插入到 index 位置

boolean addAll(Collection<? extends E> c) // 尾插 c 中的元素

E remove(int index) // 删除 index 位置元素

boolean remove(Objcet o) // 删除遇到的第一个 o

E get(int index) // 获取下标 index 位置元素

E set(int index, E element) // 将下标 index 位置元素设置为 element

void clear() // 清空

boolean contains(Object o) // 判断 o 是否在线性表中

int indexOf(Object o) // 返回第一个 o 所在的下标

int lastIndexOf(Object o) // 返回第一个 o 的下标

3.4.ArrayList的扩容机制

ArrayList是一个动态类型的顺序表，即：在插入元素的过程中会自动扩容，以下是ArrayList源码中的扩容方式：

Object[] elementData; // 存放元素的空间
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; // 默认空间
private static final int DEFAULT_CAPACITY = 10; // 默认容量大小

public boolean add(E e) {
    ensureCapacityInternal(size + 1); // Increments modCount!!
    elementData[size++] = e;
    return true;
}

private void ensureCapacityInternal(int minCapacity) {
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

private static int calculateCapacity(Object[] elementData, int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    return minCapacity;
}

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;
    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
    }
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
    private void grow(int minCapacity) {
    // 获取旧空间大小
    int oldCapacity = elementData.length;
    // 预计按照1.5倍方式扩容
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    // 如果用户需要扩容大小 超过 原空间1.5倍，按照用户所需大小扩容
    if (newCapacity - minCapacity < 0)
    newCapacity = minCapacity;
    // 如果需要扩容大小超过MAX_ARRAY_SIZE，重新计算容量大小
    if (newCapacity - MAX_ARRAY_SIZE > 0)
    newCapacity = hugeCapacity(minCapacity);
    // 调用copyOf扩容
    elementData = Arrays.copyOf(elementData, newCapacity);
}

private static int hugeCapacity(int minCapacity) {
    // 如果minCapacity小于0，抛出OutOfMemoryError异常
    if (minCapacity < 0)
    throw new OutOfMemoryError();
    return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
}

总结：

1.检测是否真正需要扩容，如果是，调用grow准备扩容

2.预估需要的库容的大小

初步预估按照1.5倍大小扩容

如果用户所需大小超过预估1.5倍大小，则按照用户所需大小扩容

真正扩容之前检测是否能扩容成功，防止太大导致扩容失败

3.使用copyOf进行扩容