数据结构-数组

最新推荐文章于 2024-09-26 03:43:29 发布

原创最新推荐文章于 2024-09-26 03:43:29 发布 · 219 阅读

0 ·

CC 4.0 BY-SA版权

随笔专栏收录该内容

70 篇文章

订阅专栏

博客介绍了数据结构中的线性结构，其中连续存储结构即数组，阐述了数组的优缺点。还讲解了二次封装数组的增删改查操作，包括基类定义、构造函数、各类方法及代码实现，最后给出了添加元素的方法及测试代码链接。

数组

数据结构中最基本的一个结构就是线性结构，而线性结构又分为连续存储结构和离散存储结构。所谓的连续存储结构其实就是数组。
优点：插入块如果知道坐标可以快速去地存取
缺点：查找慢,删除慢,大小固定

二次封装数组的增删改查
基类的定义

定义一个工具类名称-Array
接受的参数包括基本类型和自定义类型（用泛型来接受，基本类型用包装类）
自定义属性两个：size用来表示数组的大小，data用来表示一个准确的集合
概念区分：size表示数组的大小，capacity表示数组容量的大小
构造函数：有参构造，接受一个int值，用来初始化数组容量；无参构造：给容量一个默认值
toString()方法，输出数组的大小和数组容量的大小，以及数组中的值
getSize()方法，调用方通过方法来获取数组的大小
getCapacity()方法，调用方通过方法来获取数组容量的大小
isEmpty()方法，调用方通过方法来判断数组是否为空(指的是数组中是否有值，没值就为空)

基类的代码

package com.datastructure.array;

/**
 * @program: test
 * @description: 自定义数组封装工具类
 * @author: Mr.Yang
 * @create: 2019-05-01 15:36
 **/
public class Array<E> {

    private Integer size;

    private E[] data;
    /**
     * 有参构造函数
     * @param capacity  封装data的容量值
     */
    public Array(Integer capacity){
        data= (E[]) new Object[capacity];
        size=0;
    }

    /**
     * 无参构造函数，设置默认容量为10
     */
    public Array(){
        this(10);
    }

    /**
     * 获取数组中的元素个数
     * @return
     */
    public Integer getSize(){
        return size;
    }

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

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

    @Override
    public String toString(){
        StringBuffer sb = new StringBuffer();
        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();
    }
}

增

添加的方法

add()方法，两个参数，添加元素的索引位置，和元素的值
addFirst()方法，在所有元素的最前面添加
addLast()方法，在所有元素的最后面添加
添加的代码(增)

/**
     * 在索引为index的位置，插入param
     * 1.假如在索引为2的位置插入元素
     * 2.需要将原来索引为2及其以后的位置向后移动一整位
     * 3.移动完成之后，在索引为2的位置插入指定的值
     * 4.因为数组中多了一个值，所以size需要+1
     *
     * @param index 元素的索引
     * @param param 值
     */
    public void add(int index, E param) {
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("添加失败，索引的值不能小于0，并且索引的值不能大于数组的大小");
        }
        if (size == data.length) {
            throw new IllegalArgumentException("添加失败，数组的大小已经等于了数组容量的大小");
        }
        for (int i = size - 1; i >= index; i--) {
            data[i + 1] = data[i];
        }
        data[index] = param;
        size++;
    }

    /**
     * 在所有元素之前添加值
     *
     * @param param
     */
    public void addFirst(E param) {
        add(0, param);
    }

    /**
     * 在所有元素之后添加值
     *
     * @param param
     */
    public void addLast(E param) {
        add(size, param);
    }

测试代码

package com.datastructure.array;

/**
 * @program: test
 * @description:
 * @author: Mr.Yang
 * @create: 2019-05-01 16:46
 **/
public class ArrayTest {

    public static void main(String[] args) {
        Array<Integer> integerArray = new Array<Integer>(20);
        for(int i = 0; i < 10 ; i ++){
            integerArray.addLast(i);
        }
        System.out.println(integerArray);

        System.out.println("--------------------索引为3的地方添加元素-----------------------");
        integerArray.add(3,666);
        System.out.println(integerArray);

        System.out.println("--------------------所有元素的最后面添加值-----------------------");
        integerArray.addLast(10000);
        System.out.println(integerArray);

        System.out.println("--------------------所有元素的最前面添加值-----------------------");
        integerArray.addFirst(-1);
        System.out.println(integerArray);
    }
}

链接