Java顺序表解析与应用

已于 2023-08-13 10:29:56 修改
阅读量254 收藏 6
点赞数 9
分类专栏： Java数据结构 文章标签： 数据结构 顺序表 java 经验分享 学习
于 2023-08-11 07:30:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LEE180501/article/details/129371919
版权

一、顺序表概念

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

二、主要功能接口实现

Java顺序表底层就是一个动态数组。其主要功能接口如下：

// 1.打印顺序表，注意：该方法并不是顺序表中的方法，为了方便看测试结果给出的
public void display() { }
// 2.新增元素,默认在数组最后新增
public void add(int data) { }
// 3.判断当前的顺序表是不是满的
public boolean isFull() { }
// 4.在 pos 位置新增元素
public void add(int pos, int data) { }
// 5.判定是否包含某个元素
public boolean contains(int toFind) { return true; }
// 6.查找某个元素对应的位置
public int indexOf(int toFind) { return -1; }
// 7.获取 pos 位置的元素
public int get(int pos) { return -1; }
// 8.给 pos 位置的元素设为 value
public void set(int pos, int value) { }
// 9.删除第一次出现的关键字 key
public void remove(int toRemove) { }
// 10.获取顺序表长度
public int size() { return 0; }
// 11.清空顺序表
public void clear() { }

下面我们对应上面的功能接口，自己实现一下顺序表（由于这部分比较简单这里就直接给出代码，大家可结合注释参考。另外此处侧重于流程实现，使用了更好理解的int类型，并未使用泛型）：

import java.util.Arrays;
public class MyArraylist {

    public int[] elem;
    // 已使用容量，初始为0
    public int usedSize;
    // 默认容量
    private static final int DEFAULT_SIZE = 5;
	// 这里采用无参的构造方法
    public MyArraylist() {
        this.elem = new int[DEFAULT_SIZE];
    }
	
    /**
     * 1.打印顺序表  
     * 注意：该方法并不是顺序表中的方法，为了方便看测试结果给出的
     * 根据usedSize判断即可
     */
    public void display() {
        for (int i = 0; i < this.usedSize; i++) {
            System.out.print(this.elem[i] + " ");
        }
    }

	/**
	* 2.新增元素,默认尾插
	*/ 
    public void add(int data) {
        if (isFull()) {
            resize();
        }
        this.elem[this.usedSize] = data;
        this.usedSize++;
    }
	
    // 扩容
    private void resize() {
        this.elem = Arrays.copyOf(this.elem, 2 * this.elem.length);
    }

	// 检查坐标合法性
    private void checkPosInAdd(int pos) {
        if (pos < 0 || pos > this.usedSize) {
        	// 这里自定义异常类
            throw new IndexException("位置不合法，请检查位置的合法性！");
        }
    }

    /**
    * 3.判断当前的顺序表是不是满的
    */
    public boolean isFull() {
        return this.usedSize == this.elem.length;
    }
	
	/**
    * 4.在 pos 位置新增元素！
    */
    public void add(int pos, int data) {
        if (isFull()) {
            resize();
        }
        checkPosInAdd(pos);
        for (int i = this.usedSize; i > pos; i--) {
            this.elem[i] = this.elem[i - 1];
        }
        this.elem[pos] = data;
        this.usedSize++;
    }

	/**
    * 5.判定是否包含某个元素
    */
    public boolean contains(int toFind) {
        for (int i = 0; i < this.usedSize; i++) {
            if (this.elem[i] == toFind) {
                return true;
            }
        }
        return false;
    }

	/**
    * 6.查找某个元素对应的位置
    */
    public int indexOf(int toFind) {
        for (int i = 0; i < this.usedSize; i++) {
            if (this.elem[i] == toFind) {
                return i;
            }
        }
        return -1;
    }

	/**
    * 7.获取 pos 位置的元素
    */
    public int get(int pos) {
        checkPosInAdd(pos);

        return this.elem[pos];
    }

	// 判空
    private boolean isEmpty() {
        if (this.usedSize == 0) {
            return true;
        }
        return false;
    }

	/**
    * 8.将 pos 位置的元素设为修改为： value
    */
    public void set(int pos, int value) {
        checkPosInAdd(pos);
        this.elem[pos] = value;
    }

    /**
    * 9.删除第一次出现的关键字key
    */
    public boolean remove(int key) {
        int index = indexOf(key);
        if (index == -1) {
            System.out.println("不存在关键字" + key);
            return false;
        }
        for (int j = index; j < this.usedSize - 1; j++) {
            this.elem[j] = this.elem[j + 1];
        }

        this.usedSize--;
        //注意：是在这条语句之后
        //elem[usedSize] = null;
        // 如果里面是引用类型 那么此时就需要手动置空
        elem[usedSize] = 0;
        return true;

    }

	/**
    * 10.获取顺序表长度
    */ 
    public int size() {
        return this.usedSize;
    }

	/**
    * 11.清空顺序表
    */ 
    public void clear() {
        this.usedSize = 0;
    }
}

上述过程中自定义的异常类：

public class IndexException extends RuntimeException {
	// 帮助父类构造
    IndexException() {
        super();
    }
    IndexException(String msg) {
        super(msg);
    }
}

三、Java集合框架中的 ArrayList

在 java.util 包下为我们提供了一个ArrayList类，ArrayList底层是一段连续的空间，并且可以动态扩容，是一个动态类型的顺序表，且这里的 ArrayList 是以泛型方式实现的，使用时必须要先实例化。此外在Java中还对ArrayList有以下这些说明：（现阶段不做解释，大家可以暂时了解即可）

  1. ArrayList实现了RandomAccess接口，表明ArrayList支持随机访问
  2. ArrayList实现了Cloneable接口，表明ArrayList是可以clone的
  3. ArrayList实现了Serializable接口，表明ArrayList是支持序列化的
  4. 和Vector不同，ArrayList不是线程安全的，在单线程下可以使用，在多线程中可以选择Vector或者 CopyOnWriteArrayList

1、ArrayList的构造方法

方法解释
ArrayList()无参构造
ArrayList(Collection<? extends E> c)利用其他 Collection 构建 ArrayList
ArrayList(int initialCapacity)指定顺序表初始容量

解释：

  1. 对于无参构造方法ArrayList()，在实例化ArrayList对象时不会分配内存，在add()方法中才进行内存分配。
  2. 对于ArrayList(Collection<? extends E> c)，表示可以将实现了Collection接口、并且是E类型或E类型的子类的集合作为参数构造ArrayList。
  3. 相比之下ArrayList(int initialCapacity)就比较好理解了，这个构造方法是在实例化ArrayList对象时，分配指定initialCapacity大小的容量。

2、ArrayList常用方法

与此同时，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(Object o)删除遇到的第一个 o
E get(int index)获取下标 index 位置元素
E set(int index, E element)将下标 index 位置元素设置为 element
void clear()清空
boolean isEmpty()如果此列表不包含元素，则返回 true
int size()返回此列表中的元素数
boolean contains(Object o)判断 o 是否在线性表中
int indexOf(Object o)返回第一个 o 所在下标
int lastIndexOf(Object o)返回最后一个 o 的下标
List subList(int fromIndex, int toIndex)截取部分 list

3、ArrayList 的继承关系

在《Java集合框架中》我们介绍了Java集合中的继承关系，你是否还有印象ArrayList实现了List接口：

对于List接口来说，里面涵盖了ArrayList中的方法，也就是说我们可以使用 List 接口对 ArrayList 实例进行操作，因此我们可以写出类似这种调用方式：List<Integer> list = new Arraylist<>(); 将ArrayList实例交给List接口，然后直接使用list进行相关操作。

public class OperateTest {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(111);
        list.add(222);
        list.add(333);
        list.add(444);
        list.add(555);
        System.out.println(list);
        // 设定list2->[1,2,3] 便于测试addAll()
        List<Integer> list2 = new ArrayList<>();
        list2.add(1);
        list2.add(2);
        list2.add(3);
        // 末尾插入list2
        list.addAll(list2);
        System.out.println(list);

        // 获取list中有效元素个数
        System.out.println(list.size());

        // 获取和设置index位置上的元素，注意index必须介于[0, size)间
        System.out.println(list.get(0));
        list.set(0, 999);
        System.out.println(list.get(0));

        // 在list的index位置插入指定元素，index及后续的元素统一往后搬移一个位置
        list.add(1, 888);
        System.out.println(list);

        // 删除指定元素，找到了就删除，该元素之后的元素统一往前搬移一个位置
        // (这里如果直接写444会默认下标，需要使用引用类型)
        list.remove(new Integer(444));
        System.out.println(list);

        // 删除list中index位置上的元素，注意index不要超过list中有效元素个数,否则会抛出下标越界异常
        list.remove(list.size()-1);
        System.out.println(list);

        // 检测list中是否包含指定元素，包含返回true，否则返回false
        if(!list.contains(123456)){
            list.add(123456);
            System.out.println(list);
        }
        // 查找指定元素第一次出现的位置：indexOf从前往后找，lastIndexOf从后往前找
        System.out.println(list.indexOf(333));
        System.out.println(list.lastIndexOf(333));

        // 使用list中[0, 4)之间的元素构成一个新的SubList返回,
        // 但是和ArrayList共用一个elementData数组(对任一部分修改会影响整个部分)
        List<Integer> ret = list.subList(0, 2);
        System.out.println(ret);

        // 清空
        list.clear();
        System.out.println(list.size());
    }
}

4、ArrayList的遍历

（1） 方式一：
使用for循环+下标遍历

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

（2） 方式二：
由于List、Arraylist集合实现了iterable接口，可以使用增强的for循环-foreach

for (Integer x:list) {
    System.out.println(x);
}

（3） 方式三：
对于Java而言只要实现了Iterable接口的集合就可以使用迭代器 iterator

Iterator<Integer> it = list.listIterator();
while(it.hasNext()){
    System.out.println(it.next());
}

总结

本篇文章主要介绍了 Java 集合中的线性结构 ArrayList ，这是一个相对比较简单，且容易理解和实现的数据结构。这里就简单总结一下顺序表 ArrayList的优缺点：

顺序表缺点：

  1. ArrayList底层使用连续的空间，任意位置插入或删除元素时，需要将该位置后序元素整体往前或者往后搬移，故时间复杂度为O(N)
  2. 增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。
  3. 增容一般是呈倍数增长。假如以2倍扩容，势必会有一定的空间浪费，例如当前容量为100，满了以后增容到200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。

顺序表优点：

  1. 当给定下标的时候，查找速度非常快，复杂度为O(1)
不摸鱼的程序员
关注
  • 9
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 8
    评论
专栏目录
Java面试八股文解析.pptx.pptx
12-19
Java语言特性 Java是一种面向对象的编程语言，具有跨平台、安全性高、易于维护等特点，广泛应用于企业级应用开发。 Java数据类型 Java拥有8种基本数据类型，包括整型、浮点型、字符型等，以及引用数据类型如数组和类，为编程提供了丰富的数据表达能力。 Java控制结构 Java的控制结构包括顺序、选择和循环三种，通过if-else语句、switch语句和for、while等循环语句，实现程序的逻辑控制。
JAVA顺序表
qq_52988578的博客
10-02 247
顺序表：顺序表是在计算机内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系，采用顺序存储结构的线性表通常称为顺序表。 顺序表基本操作汇总： public boolean isFull()//判断顺序表是否满了 public void add(int pos, int data)//在pos位置新增元素 public void
Java顺序表的简单应用
AI新手程序员
04-21 738
应用Java顺序表添加学生信息（学号，姓名，年龄），并进行插入，删除，查找功能设置结点class DATA { String key; String name; int age; }定义顺序表结构class SLType { static final int MAXLEN = 100; DATA[] ListData = new DATA[MAXLEN + 1]; int ListLe...
java顺序表_java数据结构实现顺序表示例
weixin_36450434的博客
02-12 117
import java.util.Arrays;/*** 顺序线性表的实现*/public class LineList{private int size;//长度private Object[] array;//底层数组private final int default_length=16;//默认长度/*** 无参构造方法*/public LineList(){size = 0;/...
顺序表的应用举例
QS_Sun_24的博客
03-21 834
要求：输入学生信息表并输出 学生情况表 学号 姓名 性别 年龄 2000001 张三 男 20 2000002 李四 男 21 2000003 王五 女 22 我曾经以为这种表的存储是一行一行的把所有元素按照顺序放到数组，后来才发现，哦，原来可以定义个学生类，属性写在类里，只把学生对象放入容器。 老规
Java顺序表的实现和常用的所有基本操作(全)
qq_49818809的博客
10-29 1617
##顺序表的实现和基本操作 #顺序表的实现 public class SeqList{ private int length;//表长 private int[] datas;//数据 } #顺序表的创建和初始化 /** * 创建空的顺序表 */ public SeqList() { } /** * 创建一个指定容量的顺序表 * * @param capacity */ public SeqList
符号表解析——（2）android符号表java解析应用
pengjj1223的博客
08-17 1526
上篇 我们写了Andriod符号表解析，当对来说十分简单。（几乎都是纯java的东西） IOS符号解析相对来说比较困难。 IOS符号表为 .sYDM文件（夹） 1，大小 mapping文件一般100-150K左右，大一些的一般不会超过1M 而 .sYDM文件一般2M以上，如果工程较大，可能会超过30M 2，解析方式 不同于Android的几乎纯java的解析，很明了的对应关系 IO...
Java学习路线总结，搬砖工逆袭Java架构师
热门推荐
学Java，找哪吒
09-07 24万+
定期分享Java硬核技术干货、分享Java学习路线、分享Java经典面试题
【JAVA-Day54】Java TreeMap解析：工作原理、用法和应用实例
沉淀、分享、成长，让自己和他人都能有所收获！
10-26 2万+
作为一名Java开发者，熟练掌握集合类是至关重要的。其中，HashMap作为Java中常用的集合类之一，具有重要的地位。本篇博客将带您深入了解HashMap的各种操作技巧、实际应用场景以及面试可能涉及的问题，同时深度探讨其实现原理与性能优化，让您全面掌握HashMap的精髓。HashMap是Java中的一种数据结构，它提供了一种键值对的映射关系，允许使用键来查找值。在实际开发中，它能够高效地进行数据存储和检索，是Java编程中常用的集合类之一。
java 解析多层xml_Java高级进阶-xml解析
weixin_36312603的博客
03-02 1166
xml解析xml简介XML(eXtended Markup Language，可扩展标记性语言)，xml可以对文档和数据进行结构化处理，从而能够在部门、客户和供应商之间进行交换，实现动态内容生成，企业集成和应用开发。xml可以使我们能够更准确的搜索，更方便的传送软件组件，更好的描述一些事物。例如电子商务交易等。它的主要特点：它被设计用来传输和存储数据；被设计用来显示数据。它们都是[标准通用标记语言...
java核心知识点整理.pdf
04-19
25 JAVA8 与元数据.................................................................................................................................25 2.4. 垃圾回收与算法 .................................
Java JDK实例宝典
06-16
全部代码出自电子工业出版社夏先波的《Java JDK实例宝典》一书，本书以J2SE 5.0为开发环境，选取Java应用的典型实例，循序渐进地介绍了Java语言的各种开发方法和技巧，实例代码注释详细规范，思路清晰。 第1章 ...
JAVA核心知识点整理(有效)
03-28
25 JAVA8 与元数据.................................................................................................................................25 2.4. 垃圾回收与算法 .................................
Java面试宝典-经典
03-28
11、有数组a[n]，用java代码将数组元素顺序颠倒 80 12．金额转换，阿拉伯数字的金额转换成中国传统的形式如：（￥1011）－>（一千零一拾一元整）输出。 81 三. html&JavaScript&ajax部分 82 1. 判断第二个日期比第一...
Java数据结构————顺序表（增删改查详细实现）
执梗的博客
10-19 2320
1.什么是顺序表 在程序中，经常需要将一组（通常是同为某个类型的）数据元素作为整体管理和使用，需要创建这种元素组，用变量记录它们，传进传出函数等。一组数据中包含的元素个数可能发生变化（可以增加或删除元素）。 对于这种需求，最简单的解决方案便是将这样一组元素看成一个序列，用元素在序列里的位置和顺序，表示实际应用中的某种有意义的信息，或者表示数据之间的某种关系。 这样的一组序列元素的组织形式，我们可以将其抽象为线性表。一个线性表是某类元素的一个集合，还记录着元素之间的一种顺序关系。线性表是最基本的数据..
初阶数据结构—顺序表和链表
Awkwardx的博客
05-10 1056
新节点的 next 指针和 random 指针也都应指向复制链表中的新节点，并使原链表和复制链表中的这些指针能够表示相同的链表状态。复制链表中的指针都不应指向原链表中的节点。假设A链表相交之前的节点数是a，B链表相交之前的节点数是b，相交(含相交节点)之后的节点是c。由于快指针的速度是慢指针的2倍，相当于同样的时间快指针走过的距离（即链表的长度）是慢指针的两倍。假设链表长度为n，快指针先走k步，那么快慢指针的距离就是k，然后快慢指针同时往后走，那么当快指针遍历完链表时，慢指针走的距离就是n-k。
高效工作之软件系统——数据结构登记表
鲁迷那的专栏—坚持实践后再写出来！
05-10 745
开发完软件系统后，往往需要进行一些登记——《软件系统登记表》然后软件项目有60个表左右，难道需要手动录入，那肯定不可能工欲善其事必先利其器！go。。。同事给的模板是下图。
【数据结构】链表经典OJ题目练习（2）
HEBRE的博客
05-07 1175
思路：先分别计算出两个链表的长度，算出它们长度之间的差值deference，再让长度较长的链表先走deference步，这样两个链表的长度就会相等，再进行遍历链表，找出相交点（注意，在寻找相交点的时候要找节点的地址，不能找节点的val值）。假设slow进入环的时候slow与fast节点的距离为N，fast节点每次走两步，slow节点每次走一步，所以每当slow节点走一步的时候，快慢指针之间的距离就会缩小1，直到它们之间的距离变为0.思路：首先找到快慢指针相遇的节点，此时，meet节点就是slow指针。
【数据结构】线性表--顺序表（二）
最新发布
小林的博客
05-10 798
​ 线性表是具有相同数据类型的n(n>=0)个数据元素的有限序列，其中n为表长，当n=0时线性表是一个空表，若用L命名线性表，则其一般表示为​ L = （a1，a2，…，ai，ai+1，…，an如图所示：每个数据类型都相同，也意味着每个数据元素所占空间一样大ai是线性表中的“第i个”元素线性表中的位序a1是表头元素；an是表尾元素除第一个元素外，每个元素有且仅有一个直接前驱；除最后一个元素外，每个元素有且仅有一个直接后继​ 顺序表指的是用顺序存储的方式来实现线性表的顺序存储。
java顺序表binsert
03-20
Java顺序表是一种线性数据结构，它按照元素在内存中的顺序存储数据。顺序表的插入操作是将一个元素插入到指定位置，而不改变其他元素的位置。binsert是一种二分插入排序算法，用于在有序的顺序表中插入一个元素。 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

不摸鱼的程序员

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

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

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

打赏作者

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

抵扣说明：

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

余额充值