【Java数据结构】ArrayList顺序表

已于 2023-06-04 08:55:24 修改
阅读量344 收藏 2
点赞数 4
分类专栏： JAVA数据结构 文章标签： java 数据结构
于 2023-02-28 20:50:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Carefree_State/article/details/129269529
版权

文章目录

Java数据结构 & ArrayList顺序表

  • 我们平时很喜欢使用的数组，就是顺序表！
  • 下面我们将以 “模拟ArrayList” 的视角来盘一盘顺序表吧！
  • 在这里插入图片描述

1. ArrayList的模拟

  • 首先，这个类的功能如下：
    • 能够完成增删改查基础操作
    • 能够自动扩容（隐性，让这个顺序表能够存储足够多的数据）
    • 在一个类中放数据，这样可以给类加上一些方法，那么这个类的功能就更加丰富且有针对性，就像包装起来的一组东西（包括数组整体）
      • 在后面的链表集合类LinkedList中，虽然链表可用链表头结点表示（代表），但是这个类就是节点类吗，节点只是存储的方式，而集合类是包装起来的一组东西，即对象，通过这个对象，使用丰富的属性（包括这个链表整体）和方法

在这里插入图片描述

1.1 ArrayList的基础模板

  • 总的模板如下（具体个别方法在后面）
public class MyArrayList {

    public int[] elem;
    public int usedSize;//0
    //默认容量
    private static final int DEFAULT_SIZE = 10;

    public MyArrayList() {
        this.elem = new int[DEFAULT_SIZE];
    }

    public MyArrayList(int size) {
        if (size <= 0) {
            throw new IndexException("MyArraylist");
        }
        this.elem = new int[size];
    }

    /**
     * 打印顺序表:
     * 根据usedSize判断即可
     */
    public void display() {
        
    }

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

    public boolean isFull() {
        
    }

    /**
     * 判断当前的顺序表是不是满的！
     *
     * @return true:满   false代表空
     */

    private boolean checkPosInAdd(int pos) {
        
    }

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

    // 判定是否包含某个元素
    public boolean contains(int toFind) {
        
    }

    // 查找某个元素对应的位置
    public int indexOf(int toFind) {
        
    }

    // 获取 pos 位置的元素
    public int get(int pos) {
        
    }

    private boolean isEmpty() {
        
    }

    // 给 pos 位置的元素设为【更新为】 value
    public void set(int pos, int value) {
        
    }

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

    // 获取顺序表长度
    public int size() {
        
    }

    // 清空顺序表
    public void clear() {
        
    }
}

1.1 属性

public int[] elem;
public int usedSize;//0
//默认容量
private static final int DEFAULT_SIZE = 10;
  • elem 顺序表“本体”
  • usedSize 顺序表已添加的有效数据
  • DEFAULT_SIZE（不带参数的构造方法，在构造数组时的默认容量）

1.2 方法

1.2.1 构造方法
  • 非正常操作的异常
public class IndexException extends RuntimeException{
    public IndexException() {
        
    }

    public IndexException(String message) {
        super(message);
    }
}

public MyArrayList() {
    this.elem = new int[DEFAULT_SIZE];
}

public MyArrayList(int size) {
    if (size <= 0) {
        throw new IndexException("MyArraylist");
    }
    this.elem = new int[size];
}
  • 不带参数的构造方法
    • 以默认值构造数组
  • 带参数的构造方法
    • 以传入的值作为起始容量
1.2.2 遍历方法
  • 这个没啥好说的
    /**
     * 打印顺序表:
     * 根据usedSize判断即可
     */
    public void display() {
        if(isEmpty()) {
            System.out.println("[]");
        }
        else{
            System.out.print("[ ");
            for (int i = 0; i < this.usedSize; i++) {
                if(i == usedSize - 1) {
                    System.out.print(this.elem[i] + " ]");
                }else {
                    System.out.print(this.elem[i] + ", ");
                }
            }
            System.out.println();
        }

    }
1.2.3 增加元素方法以及判断是否满方法

在这里插入图片描述

  • 我们只需要在elem[usedSize] = data即可

    • 然后usedSize++，这样就刚好添加到数组的末尾

    • 但是，如果数组满了的话怎么办？

      • 那就要扩容一下了

      • 在这里插入图片描述

        • copyOf()这个方法可以动态调整数组的大小，对比于C语言，这个方法更加全能

        • elem2 * usedSize
          被拷贝的数组新数组的大小（我这里扩大两倍）
// 新增元素,默认在数组最后新增
public void add(int data) {
    if (isFull()) {
        //满了即扩容
        elem = Arrays.copyOf(elem, 2 * usedSize);
    }
    elem[usedSize] = data;
    usedSize++;
}

//is...() 这种命名一般返回boolean类型，起判断作用
public boolean isFull() {
    if (usedSize == elem.length) {
        return true;
    } else {
        return false;
    }
}
  • 我们还可以在指定位置进行插入（需要检验下标是否合理）
  • 我们需要将对应位置以及后面的元素都向后挪动，腾出一个位置给待插入的元素（检验是否需要扩容）
    • 从尾挪动
    • 在这里插入图片描述
//检验下标是否合理的方法
private boolean checkPosInAdd(int pos) {
    if (pos < 0 || pos > this.usedSize) {
        return false;
    }
    return true;//合法
}

// 在 pos 位置新增元素，构成重载
//pos刚好在末尾，是允许的
public void add(int pos, int data) {
    if (this.isFull()) {
        elem = Arrays.copyOf(elem, 2 * usedSize);
    }
    if (checkPosInAdd(pos)) {
        usedSize++;
        for (int i = usedSize; i > pos; i--) {
            elem[i] = elem[i - 1];
        }
        elem[pos] = data;
    }else {
        throw new IndexException("add");
    }
}
1.2.4 查找方法
  • 第一个查找-> 找得到返回true 否则false
  • 第二个查找-> 找得到返回对象下标，找不到返回-1（-1下标在java中完全用不了）
    • C语言中，访问下标arr[-1] = (arr - 1);
// 判定是否包含某个元素
public boolean contains(int toFind) {
    for (int i = 0; i < this.usedSize; i++) {
        if (elem[i] == toFind) {
            return true;
        }
    }
    return false;
}

// 查找某个元素对应的位置
public int indexOf(int toFind) {
    for (int i = 0; i < this.usedSize; i++) {
        if (elem[i] == toFind) {
            return i;
        }
    }
    return -1;
}
1.2.5 获取下标元素方法
// 获取 pos 位置的元素
public int get(int pos) {
    if (checkPosInAdd(pos)) {
        if (pos == usedSize) {
            //下标不合理就会抛异常
            throw new IndexException("get");
        } else {
            //返回对应元素的值
            return elem[pos];
        }
    } else {
        //下标不合理就会抛异常
        throw new IndexException("get");
    }
}
1.2.6 更新下标对应元素方法
// 给 pos 位置的元素设为【更新为】 value
// 即使pos刚好对应末尾，只要是“空的”就不能够设置
public void set(int pos, int value) {
    if (checkPosInAdd(pos)) {
        if (pos == usedSize) {
            throw new IndexException("set");
        } else {
            this.elem[pos] = value;
        }
    } else {
        throw new IndexException("set");
    }
}
1.2.7 是否空以及获取顺序表元素个数方法
private boolean isEmpty() {
    return usedSize == 0;
}

// 获取顺序表长度
public int size() {
    return usedSize;
}
1.2.8 删除元素方法
  • 对于第一次出现的key值，进行删除
    • 后面的所有元素要把这个空位补上去（也就是一个个挪动过去）
      • 从头挪动
      • 在这里插入图片描述
/**
 * 删除第一次出现的关键字key
 *
 * @param key
 */
public void remove(int key) {
    int index = indexOf(key);
    if (index == -1) {
        System.out.println("Can‘t find");
    } else {
        for (int i = index; i < usedSize - 1; i++) {
            this.elem[i] = this.elem[i + 1];
        }
        usedSize--;
    }
}

  • 清空顺序表的方法：

    • // 清空顺序表
public void clear() {
    this.elem = new int[DEFAULT_SIZE];
    this.usedSize = 0;
}

1.3 测试

public class Test {
    public static void main(String[] args) {
        MyArrayList myArrayList = new MyArrayList(5);
        myArrayList.display();
        myArrayList.add(1);
        myArrayList.add(2);
        myArrayList.add(3);
        myArrayList.display();
        System.out.println(myArrayList.indexOf(3));
        System.out.println(myArrayList.contains(3));
        System.out.println(myArrayList.indexOf(4));
        System.out.println(myArrayList.contains(4));
        myArrayList.add(4);
        myArrayList.add(5);
        myArrayList.add(6);
        myArrayList.display();
        myArrayList.add(2, 99);
        System.out.println(myArrayList.get(2));
        myArrayList.display();
        myArrayList.set(3, 99);
        myArrayList.display();
        myArrayList.remove(4);
        myArrayList.display();
        System.out.println(myArrayList.size());
        myArrayList.clear();
        myArrayList.display();
    }
}

在这里插入图片描述

  • 测试结果正常！

2. ArrayList的使用以及系统源码的一些细节

  • 在这里插入图片描述

  • E 是一个泛型类（不能用基本数据类型）

  • List<Integer> list = new ArrayList<>();
    • 这个是最常用的使用方式， 一般实例化List接口，这样功能更加具体

  • 如果是自定义类的话，一定要重写equals()方法，因为在查找的时候，判断是否相同尤为重要

    • 重写compareTo()方法更好，在用工具类Collections去排序的时候要用到

2.1 属性

在这里插入图片描述

  • 重点：
  • 默认数组大小，DEFAULT_CAPACITY
  • 本体数组，elementData[]
  • 有效元素个数，size
2.2.1 构造方法

在这里插入图片描述

  1. 带参数int的构造方法

    • 提供自定义数组大小，非法下标则抛异常

    • 在这里插入图片描述

    • 等于0的情况，则给一个空数组在这里插入图片描述

  2. 不带参数的构造方法

    • 以默认的数组大小构造数组
    • 在这里插入图片描述

  3. 提供一整个集合类对象作为参数的构造方法

    • 即直接将这个集合类对象的所有元素，拷贝一份下来整合成顺序表返回

    • 在这里插入图片描述

    • 但是这个集合类对象的泛型类型必须是E的子类或者E本身

2.2.2 常用方法
  • 高亮即重点
方法解释
boolean add(E e)尾插e,（返回true）
void add(int index, E element)指定位置插入元素
boolean addAll(Collection c)尾插一集合的所有元素
E remove(int index)删除指定下标的元素
boolean remove(Object o)删除第一个指定元素（不存在返回false）
E get(int index)获取下标对应元素
E set(int index, E element)设置下标对应元素（必须存在）
void clear()清空顺序表
boolean contains(Object o)判断此元素是否存在于顺序表
int indexOf(Object o)返回第一个对应元素下标
int lastIndexOf(Object o)从后往前找第一个对应元素的下标
List subList(int fromIndex, int toIndex)截取对应顺序表（sub形式的方法一般返回的对象与原对象是共用的）
  • 使用这些方法的方式更上一部分相似

2.3 顺序表的遍历

2.3.1 for-each循环(不是foreach方法)
for(Integer i : list) {
    System.out.print(i + " ");
}
2.3.2 for循环
for(int i = 0; i < list.size(); i++) {
    System.out.print(list.get(i) + " ");
}
2.3.3 listIterator() =》Iterator 迭代器实现
  • 了解即可
Iterator<Integer> iterator = list.listIterator();
while(iterator.hasNext()) {
    System.out.print(iterator.next() + " ");
}
2.3.4 直接sout（快捷）打印
  • 前提是知道泛型类型的打印方法！！！
    • 所以我们的自定义类型就必须重写toString() 方法
System.out.print(list);
  • 不难发现，List，ArrayList两个类都没有重写toString方法
  • 那么这个类的对象是怎么打印的那？
    • 其实可以在这之前已经重写好了
    • 在这里插入图片描述

2.4 toArray() 方法

在这里插入图片描述

  1. 不带参数的构造方法，直接返回对应的数组，数据类型为Object[] 需要强制类型转化为对应的类型，（由于此时的Object是对应的类型实例化的，所以不会有问题）

    • System.out.println(list.toArray()[0] instanceof Integer);
    • 在这里插入图片描述

  2. 带参数，即直接对提供的数组进行修改，返回值跟上面一样

    • 注意：不能用基本数据类型的数组，且基本数据类型数组与对象数组之间不能进行拆箱装箱

2.5 ArrayList扩容机制

在这里插入图片描述

  • 简单的来说就是
    • 满了扩容
    • 用copyOf()1.5倍扩容(位操作符速度快)
    • 超过最大容量报错

3. 实例

  • 到这里，ArrayList的基本使用与原理知识已经讲解完了，
  • 下面是一个小项目，可以去提高自己对顺序表的理解
  • 大家可以通过我写的博客去理解和完成

3.1 扑克牌系统-斗牛

(21条消息) JavaProject & 洗牌斗牛系统_Carefree_State的博客-CSDN博客

3.2 拓展：八皇后问题（非必要方法，只是结合ArrayList去解决罢了）

(21条消息) 《八皇后问题》& Java数据结构 & JavaProject & JavaOJ题集_Carefree_State的博客-CSDN博客

3.3 杨辉三角

  • 二维顺序表的表示（解题类似二维数组）
  • 在这里插入图片描述
class Solution {
    public static List<List<Integer>> generate(int numRows) {
        List<List<Integer>> list = new ArrayList();
        for(int i = 0; i < numRows; i++) {
            list.add((List<Integer>)new ArrayList());
            for(int j = 0; j < i + 1; j++) {
                if(j == 0 || i == j) {
                    list.get(i).add(1);
                }else if(i > 1 && j > 0 && j < i) {
                    list.get(i).add(list.get(i - 1).get(j - 1) + list.get(i - 1).get(j));
                }
            }
        }
        return list;
    }
}
public class Test {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int scan = scanner.nextInt();
        List list = Solution.generate(scan);
        System.out.println(list);
    }
}

文章到此结束！谢谢观看
可以叫我 小马，我可能写的不好或者有错误，但是一起加油鸭🦆！

这是我的代码仓库！（在马拉圈的23.1 / 23.2里）代码仓库

顺序表/src · 游离态/马拉圈23年1月 - 码云 - 开源中国 (gitee.com)

s:103
关注
  • 4
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
关于ArrayList的梳理
Coffee_M的博客
06-09 503
关于ArrayList的深度理解前言第1章1.第2章2.部分常用语法 前言       第1章 1.          第2章 2.          部分常用语法   首行缩进两字符（两个空格）。 高亮 灰色字体 红色字体 加粗 引用 链接: link. 删除 x下标，x上标 y=f(x)(1)y=f(x)\tag{1}y=f(x)(1) 尾注1。 表格 列1 列2 列3 a11 a12 a13 a21 a22 a23 // An h
【详解ArrayList与顺序表】
最新发布
TheMyth142857的博客
05-10 1455
本文介绍了一些ArrayList与顺序表的概念及其使用，若有不足，希望广大读者见谅！欢迎提出宝贵的意见！谢谢！！！
ArrayList与顺序表
chenbaifan的博客
12-05 645
目录ArrayList简介 ArrayList简介 在集合框架中，ArrayList是一个普通的类，实现了List接口，具体框架图如下： 【说明】 1. ArrayList实现了RandomAccess接口，表明ArrayList支持随机访问 2. ArrayList实现了Cloneable接口，表明ArrayList是可以clone的 3. ArrayList实现了Serializable接口，表明ArrayList是支持序列化的 4. 和Vector不同，ArrayList不是线程安全的，在单线程下可以
Java 集合之给ArrayList排序
Venus 的博客
02-17 9137
Java 集合之给ArrayList排序 ArrayList的排序可以借助Collections工具类的sort(List list)以及重载的sort(List list, Comparator<? super T> c)方法；其中要想使用sort(List lis)方法进行排序集合元素必须实现comparable接口中的compareTo方法；使用重载的sort(List list, Comparator<? super T> c)方法则要传入一个自定义构造器，可以使用匿名内部
Java数据结构—ArrayList顺序表
Green_756的博客
08-07 588
数据结构、ArrayList顺序表
java数据结构 ArrayList、Stack、Map
07-28
**Map** 是一个键值对（key-value pair）数据结构，它不维护元素的顺序，而是通过键来访问值。在Java中，最常用的Map实现是`HashMap`和`TreeMap`。HashMap提供快速的查找性能，因为它基于哈希表，查找、添加和删除...
数据结构静态顺序表.zip
02-03
在这个“数据结构静态顺序表.zip”压缩包中，包含的是作者用C语言实现的静态顺序表源代码。 首先，让我们深入理解静态顺序表的概念。静态顺序表是一种固定大小的数组，其长度在创建时就已经确定，且在表的整个生命...
合工大数据结构顺序表实验
04-14
本实验“合工大数据结构顺序表实验”聚焦于数据结构中的一个重要基础概念——顺序表。顺序表是一种线性数据结构，其中元素在内存中以连续的方式存储，就像数组一样。对于18级合工大的学生来说，这个实验旨在深化他们...
顺序表_顺序表_数据结构_
09-29
在编程中，许多编程语言都提供了内置的顺序表实现，如C++的`std::vector`、Java的`ArrayList`以及Python的`list`等。使用这些库函数可以方便地进行顺序表的操作，而无需从零开始实现。 总的来说，顺序表是数据结构...
数据结构顺序表-存储学生信息(Java)
03-25
本话题将深入探讨“数据结构顺序表”在Java中的实现，特别是如何利用顺序表来存储学生信息。顺序表是一种线性数据结构，其中元素在内存中以连续的方式存储，就像数组一样。下面我们将详细讲解这个过程。 首先，`...
ArrayList（顺序结构）
litengbin的博客
01-02 4043
使用数组的局限性 如果要存放多个对象，可以使用数组，但是数组有局限性 比如 声明长度是10的数组 不用的数组就浪费了 超过10的个数，又放不下 ArrayList存放对象 为了解决数组的局限性，引入容器类的概念。 最常见的容器类就是  ArrayList  容器的容量"capacity"会随着对象的增加，自动增长  只需要不断往容器里增加英雄即可，不用担心会出现数组的边界问题
java的arraylist_Java ArrayList排序的3种方法
weixin_30058099的博客
02-12 2375
首页>基础教程>集合框架>ArrayList类Java ArrayList排序的3种方法1. 使用Collections.sort()方法进行排序ArrayList 存储着以字符串形式存在的国名(country name)，为了对这个 ArrayList 进行排序，你需要调用 Collections.sort()方法，传递由国名构成的 ArrayList 对象。这种方...
ArrayList集合排序方式总结
热门推荐
ScholarTang的博客
09-19 2万+
前言 List集合是日常开发中最常用的集合类，没有之一。 在有些场景可能会需要通过程序对集合中的元素进行排序，本文总结一下List集合排序可以通过哪些方式来实现 1.使用集合的工具类Collections对ArrayList集合进行排序 简单的整数型排序： 当集合的范型为Integer类型或者为String类型并且集合中的元素为数字字符串，我们可以使用集合的工具类Collections类来对集合中的元素进行排序。 Code List<Integer> numbers = new Arra
ArrayList遍历输出的会和添加的顺序不一致吗？
evilcry2012的专栏
06-07 1万+
ArrayList遍历输出的会和添加的顺序不一致吗？List  java 正能量前线 2017年10月11日提问关注 4 关注收藏 0 收藏，1.7k 浏览问题对人有帮助，内容完整，我也想知道答案0问题没有实际价值，缺少关键内容，没有改进余地List&lt;String&gt; aList = Arrays.asList("1","2","3","4","5"); for (String st
Java数据结构-1 ArrayList顺序表实现
Xucc_x的博客
05-25 2713
1. ArrayList子类   ArrayList是JavaCollection接口下List子接口的实现子类。它是一个长度可变的数组，底层是以数组为基础的顺序表实现的。所以说研究Java顺序表数据结构必须得了解一下ArrayList类。 // ArrayList定义 public class ArrayList&amp;amp;lt;E&amp;amp;gt; extends AbstractList&amp;amp;lt;E&amp;amp;gt...
arraylist排序 java_【Java】对ArrayList排序
weixin_29879257的博客
02-20 330
java如何对ArrayList中对象按照该对象某属性排序(从小到大)两种方法：方法一：Comparator comparator = new Comparator() {@Overridepublic int compare(KNNNode o1, KNNNode o2) {System.out.println("进入 compare function");// TODO Auto-genera...
Java中ArrayList的排序两种方法以及遍历的代码
Wangzx的博客
04-19 2432
各种排序方法的比较,见我的博客: https://blog.csdn.net/qq_37486501/article/details/80141586 方法一: 在类的定义中实现Comparable接口中的compareTo()方法,然后调用Collections.sort()进行排序: import java.util.Scanner; import java.util.Arra...
数据结构顺序表的逆置Java
04-21
在Java中，可以用以下代码实现顺序表的逆置： ``` public void reverse(ArrayList<Integer> list) { int i = 0; int j = list.size() - 1; while (i ) { int tmp = list.get(i); list.set(i, list.get(j)); ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

s:103

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值