数据结构基础--数组实现[java版]

已于 2022-03-22 11:45:31 修改
阅读量403 收藏
点赞数
分类专栏： Java 数据结构 文章标签： 数据结构 java
于 2022-03-20 16:24:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42376889/article/details/123612649
版权
本文介绍了数组的概念，作为有限个相同类型变量的有序集合，数组在内存中顺序存储，适合读操作频繁而写操作较少的场景。文章详细讲解了数组的存储结构、特点，并通过代码实现了一个简单的整型数组类，包括读取、更新、插入和删除等基本操作。此外，还提供了在数组头部和尾部进行操作的方法。
摘要由CSDN通过智能技术生成

微信公众号同步更新

欢迎和小白一起成长，985计算机硕士，有任何学习，保研等问题都可以公众号私信留言哦！

微信搜索：三喂树屋
二维码：三喂树屋

数组的概念

数组是有限个相同类型的变量所组成的有序集合，数组的存储结构如下：

数组的存储结构：

在这里插入图片描述

数组的特点：

数组在内存中是顺序存储的，因此数组可以直接通过下标访问元素，读取速度较快，但插入和删除元素为了保证删除后的元素仍然是紧密相连的
，会导致大量元素被迫移动，影响效率，因此数组适合：读操作多，写操作少的场景
数组在内存中的存储结构：
在这里插入图片描述
灰色：已被占用
绿色：空闲内存

此时如果删除元素8，其后的7，9，1都需要前移来保证元素是连续连接的。
在这里插入图片描述

数组的基本操作有：

了解了数组的底层存储结构，来看一下数组的基本操作：

  1. 读取元素
    读取元素相对简单，由于数组元素是连续的，我们可以直接访问下标来获得元素值。
  2. 更新元素
    更新元素也是直接访问元素下标就可以对元素值进行更新
  3. 插入元素
    插入元素需要注意，被插入元素位置及其之后的元素要后移
  4. 删除元素
    删除元素需要注意，被删除元素后面的元素需要前移

代码实现

本次以实现一个整型数组为例，来实现数组的增删改查操作。

首先定义MyArray类和构造函数，

class MyArray{
    private int[] arr;//储存元素
    private int size;//记录元素个数
    //有参构造函数，参数为数组总容量
    public MyArray(int capacity) {
        arr = new int[capacity];
        size=0;
        }
    //不传入参数，则默认容量为10
    public MyArray(){
        this(10);
    }
    }
  1. 实现插入操作
        public void add(int index,int element){
        //如果size等于capacity，则说明数组已满
        if (size==arr.length){
            throw new IllegalArgumentException("数组已满");
        }
//        判断访问下标是否超出范围
        if (index<0||index>size){
            throw new IllegalArgumentException("超过下标");
        }
//        将index所在的元素及index后面的元素后移
        for (int i = size-1;i>=index;i--){
            arr[i+1]=arr[i];
        }
//        设置新元素
        arr[index] = element;
        size+=1;
        }

例如在index=5的位置插入元素4，步骤如下，首先7，9，1元素后移，然后将元素4插入
在这里插入图片描述
这里还给出了在数组头部和尾部添加元素的接口，本身还是调用add(id,e)函数。

//        在数组头添加元素
    public void addFist(int element){
        add(0,element);
    }
//    在数组尾添加元素
    public void addLast(int element){
        add(size,element);
    }
  1. 访问元素

访问元素比较简单，直接按照下标访问即可

public int get(int index){
        if (index<0||index>size){
            throw new IllegalArgumentException("超过下标");
        }
        return arr[index];
        }
  1. 更改元素值

和访问元素类似，通过下标访问要修改的元素，修改即可

public void set(int index,int element){
        if (index<0||index>size){
            throw new IllegalArgumentException("超过下标");
        }
        arr[index]=element;
    }
  1. 删除元素
public int remove(int index){
//        判断下标是否越界
        if (index<0||index>=size){
            throw new IllegalArgumentException("超过下标");
        }
//        返回删除的元素值
        int element = arr[index];
//        将待删除元素下标及之后的元素向前移动一位
        for (int i=index+1;i<size;i++){
            arr[i-1]=arr[i];
        }
        //元素数减1
        size--;
        return element;
    }

例如删除index=4的元素8，步骤如下，首先7，9，1元素以次前移一位，然后size–；
在这里插入图片描述
这里还给出了在数组头部和尾部删除元素的接口，本身还是调用remove(index)函数。

 public int removeFist(){
        return remove(0);
    }
    public int removeLast(){
        return remove(size-1);
    }
  1. 为了更方便的输出数组，重写了toString()函数
@Override
    public String toString() {
        StringBuilder res = new StringBuilder();
        res.append(String.format("Array: size = %d, capacity = %d\n", size, arr.length));
        res.append('[');
        for (int i = 0; i < size; i++) {
            res.append(arr[i]);
            if (i != size)
                res.append(", ");
        }
        res.append(']');
        return res.toString();
}

最后，完整代码如下：

class MyArray{
    private int[] arr;
    private int size;
    //有参构造函数，参数为数组总容量
    public MyArray(int capacity) {
        arr = new int[capacity];
        size=0;
        }
    //不传入参数，则默认容量为10
    public MyArray(){
        this(10);
    }

    public void add(int index,int element){
        //如果size等于capacity，则说明数组已满
        if (this.size==arr.length){
            throw new IllegalArgumentException("数组已满");
        }
//        判断访问下标是否超出范围
        if (index<0||index>this.size){
            throw new IllegalArgumentException("超过下标");
        }
//        将index所在的元素及index后面的元素后移
        for (int i = this.size-1;i>=index;i--){
            arr[i+1]=arr[i];
        }
//        设置新元素
        arr[index] = element;
        this.size+=1;
        }
//        在数组头添加元素
    public void addFist(int element){
        add(0,element);
    }
//    在数组尾添加元素
    public void addLast(int element){
        add(this.size,element);
    }

    public int get(int index){
        if (index<0||index>this.size){
            throw new IllegalArgumentException("超过下标");
        }
        return arr[index];
        }
    public void set(int index,int element){
        if (index<0||index>size){
            throw new IllegalArgumentException("超过下标");
        }
        arr[index]=element;
    }
    public int remove(int index){
//        判断下标是否越界
        if (index<0||index>=size){
            throw new IllegalArgumentException("超过下标");
        }
//        返回删除的元素值
        int element = arr[index];
//        将待删除元素下标及之后的元素向前移动一位
        for (int i=index+1;i<size;i++){
            arr[i-1]=arr[i];
        }
        size--;
        return element;
    }
    public int removeFist(){
        return remove(0);
    }
    public int removeLast(){
        return remove(size-1);
    }

    @Override
    public String toString() {
        StringBuilder res = new StringBuilder();
        res.append(String.format("Array: size = %d, capacity = %d\n", size, arr.length));
        res.append('[');
        for (int i = 0; i < size; i++) {
            res.append(arr[i]);
            if (i != size)
                res.append(", ");
        }
        res.append(']');
        return res.toString();
}
}

简单测试

public static void main(String[] args){
        MyArray arr = new MyArray(5);
        arr.add(0,1);
        arr.add(0,2);
        arr.add(0,3);
        arr.add(0,3);
        System.out.println(arr.toString());
        arr.set(3,4);
        System.out.println(arr.toString());
        arr.remove(0);
        System.out.println(arr.toString());
    }

输出结果：

Array: size = 4, capacity = 5
[3, 3, 2, 1, ]
Array: size = 4, capacity = 5
[3, 3, 2, 4, ]
Array: size = 3, capacity = 5
[3, 2, 4, ]
三喂树屋
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数组-java语言实现
qq_44561426的博客
12-28 385
数组 1、一维数组 1.1、概念 ​ 同一种数据类型的集合，其实数组本质就是一个容器。 1.2、定义 /* 方式一： 元素类型[] 数组名 = new 元素类型[元素个数或数组长度]; 示例： */ int[] array = new int[5]; /* 方式二： 元素类型[] 数组名 = new 元素类型[]{元素，元素，……}; 示例： */ int[] array = new int[]{1, 2, 3, 4, 5}; int[] array = {1, 2, 3, 4,
Java中的数据结构：Java实现中的详细数据结构
02-05
Java中的数据结构 重要笔记; 这是我在DS概述中了解到的数据结构实现。 这里没有乳胶材料。 几个软件包上都有未完成的代码实现，如果您想检出它，只需转到此自述文件底部的“ ToDo's”部分。 Levent Divilioglu-2017年夏季 待办事项： 附录将在此自述文件中创建 DS_011软件包：BTree实现将完成 DS_011软件包：AVLTree的实现将完成 DS_012套装：骑士之旅将被展示 DS_013套件：图表将完成 DS_013封装：实施广度优先 DS_013软件包：将要实现的Prim算法 DS_013套件：要实施的Kruskal算法
java 数组 数据结构_数据结构-JAVA实现数组
weixin_39621379的博客
02-16 156
这篇文章是展示如何使用JAVA语言实现Array这种数据结构。​1.整型数组的实现public class Array {private int[] data;private int size;/*** 构造函数，传入数组的容量 capacity 构造 Array* @param capacity*/public Array(int capacity){data = new int[capacit...
java实现数组
cyyyyyh的博客
04-04 674
private int[] elements; //用于存储数据的数组 //初始化 public MyArrey1() { elements = new int[0]; } //获取长度 public int size() { return elements.length; } //数组元素的添加 public void add(int element) { int[] newArr...
java数组的实现
weixin_30823833的博客
11-15 201
动态数组代码： import java.util.Arrays; public class Array<E> { private E[] data; private int size; //构造函数，传入数组的容量capacity的Array @SuppressWarnings("unchecked") ...
Java 简单实现数组
amy acker的博客
03-04 254
简单实现数组 public class Array&amp;amp;lt;E&amp;amp;gt; { private E[] array; private int size; //无参构造函数，默认容量为10 public Array(){ this(10); } //有参构造函数 public Array(int capacity){ ...
Java数组的简单实现
boneinegg的博客
08-11 1758
Java将数组封装为类的简单实现 public class Array { private long[] array; private int length = 0; //构造 public Array(int size) { array = new long[size]; } //插入，增加数组长度 public v...
【数据结构与算法】数组应用4：多项式计算Java版
weixin_34128501的博客
10-28 257
    这里讨论的是多项的加法，直接看下面的程序代码：package chapter02; import java.util.Arrays; /*  * 多项式加法（简单版）  * A(x) = 2x^5 + 3x^4 + 0x^3 + 5x^2 + 4x^1 +1x^0  * B(x) =        3x^4 + 2x^3 + 1x^2 + 1x^1 + 2x^0  *   * A(x)...
Java的数组
qq_45677189的博客
06-07 285
Java的数组
java基础---数组的数据结构
鱼非子
02-07 453
引言 在学习JAVA的基础的时候，我们只是简单的学习了数组的定义和怎么访问数组的元素，而且JAVA内部也替我们实现了数组的基本操作，我们没有过多的去考虑数组底层实现，所以本篇文章主要讲有关于数据结构里面的数组的基本操作，不会利用JAVA数组本身实现的操作，我们自己实现这些内部的底层。 数组的定义 数组是相同类型的 、用一个标识符名称来封装到一起的一个对象序列或基本类型的数据序列；也就是说数组充当一...
Java数组实现简单队列（一）
weixin_53617298的博客
08-15 158
队列数组队列数组代码 队列 先来稍微了解一点队列： 1.队列是一个先进先出的抽象数据结构，通常情况下，队列有数组和链表两种实现方式。 2.可类比于生活中的排队。 3.Java 定义了队列的基本操作，接口类型为 java.util.Queue，定义了add、remove、element 操作 offer，poll、peek 操作等，是一个较为复杂的数据结构，本文仅从数组角度j 数组 1.数组指的是一组相关类型的变量集合，这些变量可以按照统一的方式进行操作。 2.数组的声明： 数据类型 [] 数组名称 = n
java用数组模拟实现ArrayList以及一些常用方法实现
u011424470的专栏
05-04 3614
package com.yys.student; /** * Created by yys on 2017/5/4. */ public class SxtArrayList { private Object[] elementDate; private int size; /** * 默认无参构造方法 SxtArrayList() */
Java实现基本数据结构——数组
07-12 1949
首先，我们先设计一个静态的数组，以int数组为例。不考虑扩容，先从最简单的类来理解数组的基本功能。 数组可以表示为下图：上图代表一个容量为7，里面每个空间存储了一个int类型的 1 ，这样一个数组。 数组最大的优点就是通过索引值快速查询数据，比如array[2]可以快速查询到第三个空间中的数据 1 。根据这个优点，我们可以想到，数组比较适合存储索引有语义的数据，比如成绩单这种，我们把名次当做索引，分数当做数据用一个数组存储起来，就可以快速获取某个名次的分数。 按照这个数组，我们可以设计一个数组类，首先设计好
Java—常用的数据结构—数组
LiLi的博客
07-31 1769
理解数组 试想一下，如果编写一个程序，需要储存12个月份的天数，是否要定义12个变量呢？如果编写一个扑克程序，里面应该需要储存54张扑克的信息，是否要定义54个变量？而如果程序需要储存上成千上万的数据，程序员是不是也要逐一定义成千上万个变量？如果这样做一是工程量太大，而是这些逐一定义的变量间彼此独立，没有任何内在联系，这会对维护这些变量带来巨大困难，有时甚至无法处理。为了解决这个问题，聪明的程序设计者创造了数组这个好用的数据结构。数组概念的引入，大大方便了程序的设计，如下图所示。 数组（Array），顾名
java数据结构，线性表顺序存储（数组）的实现
最新发布
m0_63622279的博客
11-20 1220
线性表（linear list）是数据结构的一种，一个线性表是n个具有相同特性的数据元素的有限序列。接着用类去实现这一接口，重写其中的全部方法，因为有一些操作，使用静态方法更便捷，所以接口中只是部分的基础操作，线性表的增删改查。7）Insert（L，i，x）在表L的位置i处插入元素x，将原占据位置i的元素及后面的元素都向后推一个位置。数据结构陆续更新中！3）Get（L，i） 这是一个函数，函数值为L中位置i处的元素（1≤i≤n）6）Locate（L，x） 这是一个函数，函数值为元素x在L中的位置。
链表的实现（Java）
Alexwym的博客
07-08 3814
前面我们已经使用顺序表实现了一个动态数组，当然动态数组还有另一种实现形式——链表。这里就涉及到另一个问题，JAVA中有没有指针？严格来说JAVA是没有真正意义上的指针的，它只有引用。具体的分析我们这里暂不做讨论。接下来我们就利用JAVA的引用来实现一个动态数组，也就是链表。 一、链表的物理结构 链表是由一个个独立的节点组织起来的，它具有真正意义上的动态。顺序表在计算机内部是顺序储存的，它每次在...
手写数组的底层实现(java实现)
央小木的博客
03-27 3258
打造属于自己的Array ​ 查看JDK1.8中ArrayList源码时，其中的Arrays.copyOf为Native方法，具体怎么实现的并没有。所以打算自己实现，来深入了解一下Array这个数据结构。 静态数组 创建增删改查方法 自己创建数组无非就是数组的 增删改查 方法的创建，即 add,remove,set,get 方法。 首先创建一个简单的int集合来表示数组，默认...
java使用数组实现队列
热门推荐
morris
02-14 1万+
1.1.  队列的数据结构 队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。 1.2.  Java实现 QueueTest package ch04; public class QueueTe
java实现数据结构---数组
叶小刀
08-23 237
package DataDtructure; import java.util.ArrayList; /** * ClassName: Array * Company:华中科技大学电气学院 * date: 2019/8/20 22:33 * author： YEXIN * version： 1.0 * since： JDK 1.8 * Description:数组 */ pu...
Java数据结构：链表与数组实现栈的深度解析
"Java数据结构篇-链表与数组实现栈深入理解栈的基本概念及操作，探讨了如何用链表和数组在Java中构建栈，强调了数据结构在编程中的重要性。" 在计算机科学中，数据结构是设计和实现算法的基础，它涉及如何有效地...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

三喂树屋

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

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

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

打赏作者

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

抵扣说明：

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

余额充值