Java自定义动态数组

最新推荐文章于 2024-08-03 12:59:04 发布
最新推荐文章于 2024-08-03 12:59:04 发布
阅读量1.3w 收藏 50
点赞数 13
分类专栏： Java 数据结构 文章标签： Java自定义动态数组 Java静态数组向动态数组转变 Java动态数组扩容 Java动态数组测试代码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/longgeqiaojie304/article/details/87311625
版权

Java自定义动态数组

1、静态数组向动态数组转变

（1）静态数组，数组空间固定长度

这个数组空间总长为4，如果此时新插入一个数据就会报数组空间不足

 

（2）静态数组如何转变成动态数组

第一步：创建一个空间是data数组两倍的newData数组（扩容）；

第二步：把data数组中的元素全部赋值到newData数组；

 

2、数组扩容程序

// 数组扩容
private void resize(int newCapacity){
    E[] newData = (E[]) new Object[newCapacity];
    for (int i = 0; i < size; i++) {
        newData[i] = data[i];
    }
    data = newData;
}

数组添加元素：数组空间不够就会扩容（原来空间2倍）

    // 数组指定位置添加元素
    public void add(int index, E e) {
//        if (size == data.length)
//            throw new IllegalArgumentException("Add failed.Array is full.");
        if (index < 0 || index > size)
            throw new IllegalArgumentException("Add failed. Require index >= 0 and index <= size");
        if (size == data.length)
            resize(2 * data.length);
        for (int i = size - 1; i >= index; i--)
            data[i + 1] = data[i];
        data[index] = e;
        size++;
    }

数组删除元素：数组空间空闲太大就会缩容（原来空间的1/2）

// 从数组中删除index位置的元素，返回删除的元素
public E remove(int index) {
    if (index < 0 || index >= size) {
        throw new IllegalArgumentException("Remove failed.Index is illegal");
    }
    E ret = data[index];
    for (int i = index + 1; i < size; i++) {
        data[i - 1] = data[i];
    }
    size--;
    // loitering objects != memory leak 手动释放内存空间
    data[size] = null;
    if(size == data.length / 2) {
        resize(data.length / 2);
    }
    return ret;
}

 

3、数组整体代码

public class Array<E> {
    // 定义数组变量，data.length表示数组容量capacity
    private E[] data;
    // 定义数组中存放数据大小
    private int size;

    // 有参构造方法，传入数组的容量capacity构造动态数组
    public Array(int capacity) {
        data = (E[])new Object[capacity];
        size = 0;
    }

    // 无参构造方法，默认初始容量为capacity=10
    public Array() {
        this(10);
    }

    // 获取数组中元素个数
    public int getSize() {
        return size;
    }

    // 获取数组的容量
    public int getCapacity() {
        return data.length;
    }

    // 判断数组是否为空
    public boolean isEmpty() {
        return size == 0;
    }

/*    // 在数组末尾添加元素
    public void addLast(E e) {
        if (size == data.length)
            throw new IllegalArgumentException("AddLast failed.Array is full.");
        data[size] = e;
        size++;
    }*/

    // 在数组末尾添加元素（复用add方法）
    public void addLast(E e) {
        add(size, e);
    }

    // 在数组头部添加元素（复用add方法）
    public void addFirst(E e) {
        add(0, e);
    }

    // 数组指定位置添加元素
    public void add(int index, E e) {
//        if (size == data.length)
//            throw new IllegalArgumentException("Add failed.Array is full.");
        if (index < 0 || index > size)
            throw new IllegalArgumentException("Add failed. Require index >= 0 and index <= size");
        if (size == data.length)
            resize(2 * data.length);
        for (int i = size - 1; i >= index; i--)
            data[i + 1] = data[i];
        data[index] = e;
        size++;
    }

    // 获取index索引位置的元素
    public E get(int index) {
        if (index < 0) {
            throw new IllegalArgumentException("Get failed.Index is illegal.");
        }
        return data[index];
    }

    // 修改index索引位置的元素
    public void set(int index, E e) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("Set failed.Index is illegal.");
        }
        data[index] = e;
    }

    // 查找数组中是否存在元素e
    public boolean contains(E e) {
        for (int i = 0; i < size; i++) {
            if (data[i] == e) {
                return true;
            }
        }
        return false;
    }

    // 查找数组中元素e所在的索引，如果不存在元素e，则返回-1
    public int find(E e) {
        for (int i = 0; i < size; i++) {
            if (data[i] == e) {
                return i;
            }
        }
        return -1;
    }

    // 从数组中删除index位置的元素，返回删除的元素
    public E remove(int index) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("Remove failed.Index is illegal");
        }
        E ret = data[index];
        for (int i = index + 1; i < size; i++) {
            data[i - 1] = data[i];
        }
        size--;
        // loitering objects != memory leak 手动释放内存空间
        data[size] = null;
        if(size == data.length / 2) {
            resize(data.length / 2);
        }
        return ret;
    }

    // 删除数组第一个元素，返回删除的元素
    public E removeFirst() {
        return remove(0);
    }

    // 删除数组最后一个元素
    public E removeLast() {
        return remove(size - 1);
    }

    // 删除数组中指定元素e
    public void removeElement(E e) {
        int index = find(e);
        if (index != -1) {
            remove(index);
        }
    }

    // 数组扩容
    private void resize(int newCapacity){
        E[] newData = (E[]) new Object[newCapacity];
        for (int i = 0; i < size; i++) {
            newData[i] = data[i];
        }
        data = newData;
    }

    // 重写父类toString()方法
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append(String.format("Array: size = %d , capacity = %d\n", size, data.length));
        sb.append('[');
        for (int i = 0; i < size; i++) {
            sb.append(data[i]);
            if (i != size - 1) {
                sb.append(',');
            }
        }
        sb.append(']');
        return sb.toString();
    }
}

4、数组测试代码

public class ArrayTest {
    public static void main(String[] args) {
        // 测试toString()方法
        Array<Integer> arr = new Array(10);
        for (int i = 0; i < 10; i++) {
            // 测试addLast(int e)方法
            arr.addLast(i);
        }
        System.out.println("添加数组元素：");
        System.out.println(arr);

        // 测试add(int index, int e)方法
        arr.add(1, 200);
        System.out.println("在数组指定索引位置插入元素e：");
        System.out.println(arr);

        // 测试addFirst(int e)方法
        arr.addFirst(-10);
        System.out.println("在数组头部位置插入元素e：");
        System.out.println(arr);

    }
}

测试结果如下所示：初始化数组空间大小为10，第一次插入10个元素到数组之后，然后再添加一个元素，此时数组会扩容为原来空间的两倍。

添加数组元素：

Array: size = 10 , capacity = 10

[0,1,2,3,4,5,6,7,8,9]

在数组指定索引位置插入元素e：

Array: size = 11 , capacity = 20

[0,200,1,2,3,4,5,6,7,8,9]

在数组头部位置插入元素e：

Array: size = 12 , capacity = 20

如果感兴趣的童鞋，可以观看我下一篇博客：简单复杂度分析

Drogon Brother
关注
专栏目录
c++ 知识点 ： 动态定义数组
清流弯弯
11-17 2万+
首先：为什么需要动态定义数组呢？ 这是因为，很多情况下，在预编译过程阶段，数组的长度是不能预先知道的，必须在程序运行时动态的给出 但是问题是，c++要求定义数组时，必须明确给定数组的大小，要不然编译通不过 如： int Array[5];正确 int i=5; int Array[i]; 错误 因为在编译阶段，编译器并不知道 i
java怎样定义动态数组_java如何手写动态数组？实例代码展示
weixin_35639230的博客
02-27 1267
自从21世纪以来。科学技术水平高速发展，这也促使了新兴技术的不断发展与壮大。越来越多的人开始投入到新技术的学习当中来。其中java的学习则是更多人的选择。今天就为大家介绍一下java如何手写动态数组，并用实际代码展示。一起来看看吧。首先说一下注意事项。1.在定义增量时，不要定义成一个固定的值，每次扩充一定比例。2.比例不是越大越好，也要考虑到内存问题，所以取个合适的值就行。3. 在Array中的s...
Java动态数组
深未来技术
03-14 130
Java动态数组是一种可以任意伸缩数组长度的对象，在Java中比较常用的是ArrayList，ArrayList是javaAPI中自带的java.util.ArrayList。下面介绍一下ArrayList作为Java动态数组的用法。   1.语法：add()是添加一个新的元素,remove()删除一个元素,size()获得ArrayList的长度。ArrayList的下标是从0开始。 ...
Java中如何定义一个数组？
最新发布
牧夏的个人博客
08-03 1319
首先，你需要声明一个数组的类型和名称。你可以在定义的同时直接初始化数组。// 创建一个大小为10的整数数组，默认值为0声明数组初始化数组声明并初始化使用初始化列表了解这些基本操作后，你可以根据需要在Java程序中灵活使用数组。
JAVA之动态数组
weixin_66942853的博客
05-24 7019
目录 一、什么是动态数组 二、动态数组的实现 一、什么是动态数组 Java中提供的数组都是静态数组，即在一个数组定义时确定长度后，使用过程中无法修改此长度。 动态数组就是在普通数组上，增加了一个可以根据元素的个数动态调整数组大小的功能。 二、动态数组的实现 1.创建一个Object类型的value数组，设置数组长度为length，数组元素数为size，并且初始化构造方法 public class MyList { Object[] values;// 什么数据都可以存
java动态数组
qq_63533526的博客
01-07 1763
创建数组时，先在堆空间内使用足够的内存空间放需要大小的元素（不一定和放的元素本身一样大），然后在向数组内添加元素内容时再调用相应内存大小，便于节省内存同时可以确保能够保存不同类型的元素。清空数组后，可能以后还需要使用，如果直接将数组对象与连接元素地址的指针断开，数组会被直接销毁，也就是数组占用的地址直接不存在了，没办法再进行其他操作了，这个数组就不能再使用了。当然，要用到对象数组，即在动态数组中存的不是数值，而是其他数组的对象时， 格式就会有所不同。（1）9（常数） 用大O表示法后变成O（1）
java自定义数组_Java自定义数组
weixin_34430692的博客
02-12 1744
前言今天有点无聊,写了一个自定义数组,里边主要实现很多js中数组的方法，例如：排序、数组连接、删除、剪切。算是加深对java的一些基础操作的印象。代码/*** @Auther dbc* @Date 2020/9/5 22:03* 自定义数组,数组元素为Object类* 构造方法：* MyArrayList() 初始化数组,长度为0* MyArrayList(int size) 创建长度...
自定义实现Java动态数组
野犬17的博客
03-27 1591
写在前面 通常，我们会用高级程序语言中的数组来描述线性表的顺序存储结构，而这种顺序表的特点时逻辑顺序与物理顺序相同，即数组中元素的内存地址是连续的。 那么很显然，这样的数组（静态数组）是在空间被占满后再往里添加数据，就会发生溢出，进而导致程序崩溃。 ...
java 创建自定义数组
09-02
在Java编程语言中，创建自定义数组意味着我们不使用基本数据类型（如int、double等）来创建数组，而是使用自定义的类实例。自定义类通常包含特定于业务逻辑的属性和方法。在这个例子中，`Student` 类被用作自定义...
自定义动态数组
cui1004的博客
07-07 1361
/** * 数组：动态数组，泛型 * * @author f242 * @since V1.0.0 * 2020-03-19 15:26 */ public class Array<E> { private E[] data; private int size; /** * 构造函数：传入数组的容量capacity构造Array ...
java学习--动态数组
2301_78713336的博客
10-06 1762
数组是内存的一块连续空间数组可以通过下标进行访问数据下标：从0开始依次递增长度：整个数组中可以存储的元素个数。
自定义Java动态数组
lilei的博客
06-16 2300
前言: 基于java提供的静态数组,自定义实现的动态数组 代码如下: /** * @ClassName Array * @Description 基于java数组进行二次封装 * @Author lilei * @Date 16/06/2019 11:09 * @Version 1.0 **/ public class Array<E> { private E...
java 自定义一个动态数组容器
lq774879924的博客
04-27 274
下面展示一些 内联代码片。 package com.javatest; /* 自定义一个容器类型：MyArrayList 底层是数组 */ import java.util.Arrays; public class MyArrayList { private Object[] data; private int total; public MyArrayList(...
java 定义动态数组_动手编写—动态数组（Java实现）
weixin_39651325的博客
02-20 1161
数组基础回顾1、数组是一种常见的数据结构，用来存储同一类型值的集合2、数组就是存储数据长度固定的容器，保证多个数据的数据类型要一致3、数组是一种顺序存储的线性表，所有元素的内存地址是连续的4、例如：new 一个int基本类型的数组arrayint[] array = new int[]{11,22,33};5、数组的优势与劣势数组具有很高的随机访问能力，通过数组下标就可以读取对应的值数组在插入与删...
JAVA之动态数组（实例说明）
qq_63179750的博客
04-22 988
JAVA之动态数组（实例说明）
Java自定义数组排序实现
"本文将介绍如何在Java中实现数组的自定义排序，特别是针对特定值的特殊排序方式。" 在Java编程语言中，数组是一种基本的数据结构，用于存储同类型的元素集合。数组的排序是常见的操作，Java提供了多种内置的排序...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值