java 数据结构ArrayList类

N_0050

已于 2024-04-10 20:50:06 修改

阅读量1.4k

点赞数 22

分类专栏： java数据结构文章标签： java 数据结构

于 2024-02-14 17:52:43 首次发布

本文链接：https://blog.csdn.net/N_0050/article/details/136114388

版权

java数据结构专栏收录该内容

9 篇文章 0 订阅

订阅专栏

什么是List

在集合框架中，List是一个接口，继承自Collection。

注意：List是个接口，并不能直接用来实例化

Collection也是一个接口，该接口中规范了后序容器中常用的一些方法，具体如下所示：

List中提供好了的方法，具体如下：

线性表

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

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

顺序表

其实是一个动态扩容的数组

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

接口的实现：

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() { }
// 打印顺序表，注意：该方法并不是顺序表中的方法，为了方便看测试结果给出的
    public void display() { }
}

ArrayList类

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

说明

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

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

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

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

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

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

ArrayList无参方法

无参一开始的时候没有分配内存，当调用add方法的时候才分配内存，因为底层代码进行扩容等一系列操作

    public static void main2(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(0, 99);

        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i) + " ");
        }
        System.out.println();
        System.out.println(list);

结论：

第一次Add的是会分配大小为10的内存

对于ArrayList来说，都是以1.5倍进行扩容

ArrayList有参方法

简单点说把一整个集合的一组内容拿过来填充到link里

    public static void main3(String[] args) {
        LinkedList<Integer> link = new LinkedList<>();
        link.add(1);
        link.add(2);
        link.add(3);

        ArrayList<Number> list2 = new ArrayList<>(link);
        list2.add(21);
        list2.add(22);
        System.out.println(list2);

下面通配符中解释了有参方法的传递以及注意的点

？通配符

?就是你传入的变量的指定的泛型类型就是图中list的Integer

E就是图中的list12的泛型类型Number

c就是List

只要实现了Collection接口的都能传，还有传入的类型得是list12 Number的子类或者本身

ArrayList 的remove方法

在使用 remove(Object o) 方法从列表中移除特定对象时，需要传递一个与要移除的对象逻辑上相等的新对象作为参数。这是因为 remove(Object o) 方法会根据对象的相等性来确定要移除的元素

    public static void main5(String[] args) {
        LinkedList<Integer> link = new LinkedList<>();
        link.add(1);
        link.add(2);
        link.add(3);

        ArrayList<Number> list2 = new ArrayList<>(link);
        list2.add(21);
        list2.add(22);
        System.out.println(list2);

        list2.remove(2);
        list2.remove(new Integer(2));
        System.out.println(list2);

    }

ArrayList 的subList方法

    public static void main7(String[] args) {
        LinkedList<Integer> link = new LinkedList<>();
        link.add(1);
        link.add(2);
        link.add(3);

        //不会产生新的对象
        List<Integer> link1 = link.subList(1, 3);
        System.out.println(link1);
        link1.set(0, 99);
        System.out.println(link1);
        System.out.println(link);
    }

如图所示subList方法不是创建一个新的arraylist对象，subList 返回的对象实际上是原始列表的一个引用，它指向原始列表中指定范围的元素，简单说就是把那一段的地址给到了list1

Iterator：迭代器

public static void main11(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);

        //迭代器
        Iterator<Integer> it = list.iterator();
        //Iterator<Integer> it1 = list.listIterator();
        while (it.hasNext()) {
            System.out.print(it.next() + " ");
        }
        System.out.println();
    }

使用ArrayList完成杨辉三角

public class Test {
    //杨辉三角
    public static List<List<Integer>> generate(int numRows) {

        List<List<Integer>> ret = new ArrayList<>();//二维数组

        List<Integer> list = new ArrayList<>();//第一行
        list.add(1);
        ret.add(list);//把第一行数据存进二维数组里

        //从第二行开始
        for (int i = 1; i < numRows; i++) {
            List<Integer> curRow = new ArrayList<>();//当前行
            curRow.add(1);//第一个下标设置为1

            List<Integer> preRow = ret.get(i - 1);//上一行

            //下标从一开始，因为已经设置了第一个下标了
            for (int j = 1; j < i; j++) {
                int val = preRow.get(j) + preRow.get(j - 1);
                curRow.add(val);//存进当前行
            }
            curRow.add(1);//当前行循环结束后，最后一个下标设置为1
            ret.add(curRow);//然后把当前添加到ret二维数组里
        }
        return ret;
    }