封装自己的java数组

最新推荐文章于 2024-03-21 09:51:03 发布
最新推荐文章于 2024-03-21 09:51:03 发布
阅读量1.5k 收藏 16
点赞数 3
分类专栏： javaSE 文章标签： java ArrayList 数组
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36258498/article/details/84986729
版权

文章目录


最近研究了下Arraylist的底层实现，我在这里基于Arraylist底层的实现思想，这里基于对java的数组进行一个简单的封装，实现一个类似Arraylist的自定义的数组类。

1.封装数组类

在我们自定义的数组中要指定一个容量大小的变量capacity，一个数组实际大小的变量size，size也是指向数组中第一个没有元素的位置，首先自定义一个类，这里先指定数组存放的数据类型为int，后面会使用泛型进行优化

public class Array {
    //因为数组的长度也就是我们这个数组的容量大小，所以这里就少维护一个变量
    private int[] data;
    //数组中的元素个数
    private int size;

    /**
     * 用户在创建类的时候传入该数组的容量大小
     * @param capacity
     */
    public Array(int capacity){
        data =new int[capacity];
        size=0;
    }

    /**
     * 如果用户在创建的时候不传入参数，则调用有参构造函数，并将容量默认设置为10
     */
    public Array(){
        this(10);
    }
    /**
     * 查询数组的容量大小
     * @return
     */
    public int getCapacity(){
        return data.length;
    }

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

}

2.实现向数组中添加元素

  • 在数组的末尾添加元素：首先前面介绍过，size就是指向数组中第一个没有元素的位置，所以如果要想实现向数组中最后一个位置添加元素的操作，只需要向size的位置添加元素即可，在添加完后，将size的值就行+1的操作，需要注意的是在执行添加操作之前需要对数组的容量大小进行判断，如果数组中的元素个数等于数组的容量的时候需要抛出一个异常来提示用户，后面会进行动态扩容的优化。
public void addLast(int e){
	if (size==data.length){
            throw new RuntimeException("数组容量已满");
        }
        data[size]=e;
        size++;
    }
  • 向数组中的指定位置插入元素：如果要向数组中指定的位置添加元素，我们需要将该索引后面的元素依次向后面移动一个位置，将需要插入的索引位置的数据让出来，为了不发生数组的覆盖，我们应该从数组中最后一个元素开始移动，直到将用户选择插入的索引位置的元素也移动到下一位时候停止，然后将用户传入的数据插入到该位置，将size++，还要对用户传入的索引值进行一下判断，该所以必须大于等于0，且不能大于size的值，否则数据会出现不连续的情况。
 public void  add(int index ,int e){
        if (size==data.length){
            throw new RuntimeException("数组容量已满");
        }

        if(index<0|| index>size){
            throw new RuntimeException("索引值不符合要求");
        }

        for (int i=size-1;i>=index;i--){
            data[i+1]=data[i];
        }
        data[index]=e;
        size++;
    }

定义了该方法后，前面所定义的addLast就可以直接复用该方法了，可以使代码更加简洁

public void addLast(int e){
      add(size,e);
    }

向数组的头部添加元素：实现思路和前面的相同只需要向数组中的第0个位置添加一个元素即可

 public void addFirst(int e){
        add(0,e);
    }

3.实现数组的查询元素和修改元素

  • 为了方便查看数组中的元素，我们先书写一个toString的方法
@Override
    public String toString() {
        StringBuffer stringBuffer=new StringBuffer();
        stringBuffer.append("数组的元素的个数为"+size+"\r\n"+"数组的容量为"+data.length+"\r\n");
        stringBuffer.append("[");
        for (int i=0;i<size;i++){
            stringBuffer.append(data[i]);
            if (i!=size-1){
                stringBuffer.append(",");
            }
        }
        stringBuffer.append("]");
        return stringBuffer.toString();
    }
  • 创建一个方法，用户传入索引值，就可以获取到该索引上的元素的值，首先要先对该索引进行判断，如果该索引小于0或者大于size值会抛出异常，索引符合要求时会从返回data中的该索引的元素
public int get(int index){
        if (index<0||index>size){
            throw  new RuntimeException("索引值不符合要求");
        }
        return data[index];
    }
  • 修改指定索引上的元素，同样先对传入的索引值进行判断，然后将data对应传入的索引值上的元素修改为用户传入的值
 /**
     * 修改指定索引上的元素
     * @param index
     * @param e
     */
    public void set(int index , int e){
        if (index<0||index>=size){
            throw  new RuntimeException("索引值不符合要求");
        }
        data[index]=e;
    }
  • 传入一个元素，查看该元素是否存在于该数组中，如果存在返回true，如果不存在返回false，遍历data数组，将每个索引位置的元素取出和传入的元素进行对比，如果相等返回true，否则返回false
 public boolean contain(int e){
        for (int i=0;i<size;i++){
            if (data[i]==e){
                return true;
            }
        }
        return false;
    }
  • 查询方法，传入一个元素，返回该元素所在位置的索引值，如果该元素不存在则返回-1，复用上面的contain方法，先对该元素进行判断是否存在于数组之中，如果存在则进行循环遍历，如果不存在则可以直接返回-1
    public int find(int e){
        boolean b = contain(e);
        if (b){
            for (int i=0;i<size;i++){
                if (data[i]==e){
                    return i;
                }
            }
        }
        return -1;
  }

4.实现删除元素

  • 实现删除元素的功能，用户传入索引值，删除该索引值上的元素，该方法的实现和添加元素类似，对于添加元素来说是需要将要插入的索引位置后面的元素都向后面一次赋值，然后再将元素写入，对于删除来说就是讲要删除的索引位置之后的元素全部都向前面一个位置进行赋值操作，维护size变量，对size变量进行减一，并返回要删除的索引上的元素值
   public int remove(int index){
        if (index<0||index>=size){
            throw new RuntimeException("索引值不符合规范");
        }
        int e=data[index];
        for (int i=index+1;i<size;i++){
            data[i-1]=data[i];
        }
       size--;
        return  e;
    }

5.使用泛型对数组进行改良

因为我们前面定义的数组为int类型的，只能存放int类型的数组，存在一定得局限性，所以我们将该数组设置一个泛型，可以用来存放所有的元素


public class Array<E> {
    //因为数组的长度也就是我们这个数组的容量大小，所以这里就少维护一个变量
    private E[] data;
    //数组中的元素个数
    private int size;

    /**
     * 用户在创建类的时候传入该数组的容量大小
     * @param capacity
     */
    public Array(int capacity){
        //因为java中不支持直接创建泛型的数组，所以先创建一个object类型的数组，然后再强转为泛型数组
        data = (E[])new Object[capacity];
        size=0;
    }

    /**
     * 如果用户在创建的时候不传入参数，则调用有参构造函数，并将容量默认设置为10
     */
    public Array(){
        this(10);
    }

    /**
     * 查询数组的容量大小
     * @return
     */
    public int getCapacity(){
        return data.length;
    }

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

    /**
     * 向数组的尾部添加一个元素
     * @param e
     */
    public void addLast(E e){
      add(size,e);
    }

    /**
     * 向数组的头部添加一个元素
     * @param e
     */
    public void addFirst(E e){
        add(0,e);
    }

    /**
     * 向数组的任意位置添加一个元素
     * @param index
     * @param e
     */
    public void  add(int index ,E e){
        if (size==data.length){
            throw new RuntimeException("数组容量已满");
        }

        if(index<0|| index>size){
            throw new RuntimeException("索引值不符合要求");
        }

        for (int i=size-1;i>=index;i--){
            data[i+1]=data[i];
        }
        data[index]=e;
        size++;
    }

    @Override
    public String toString() {
        StringBuffer stringBuffer=new StringBuffer();
        stringBuffer.append("数组的元素的个数为"+size+"\r\n"+"数组的容量为"+data.length+"\r\n");
        stringBuffer.append("[");
        for (int i=0;i<size;i++){
            stringBuffer.append(data[i]);
            if (i!=size-1){
                stringBuffer.append(",");
            }
        }
        stringBuffer.append("]");
        return stringBuffer.toString();
    }

    /**
     * 获取指定索引上的元素
     * @param index
     * @return
     */
    public E get(int index){
        if (index<0||index>size){
            throw  new RuntimeException("索引值不符合要求");
        }
        return data[index];
    }

    /**
     * 修改指定索引上的元素
     * @param index
     * @param e
     */
    public void set(int index , E e){
        if (index<0||index>=size){
            throw  new RuntimeException("索引值不符合要求");
        }
        data[index]=e;
    }

    /**
     * 查询传入的元素在数组中的索引，如果该元素不存在则返回-1
     * @param e
     * @return
     */
    public int find(E e){
        boolean b = contain(e);
        if (b){
            for (int i=0;i<size;i++){
                if (data[i].equals(e)){
                    return i;
                }
            }
        }
        return -1;
  }

    /**
     * 查看数组中是否包含某个元素，如果包含返回true，否则返回false
     * @param e
     * @return
     */
    public boolean contain(E e){
        for (int i=0;i<size;i++){
            if (data[i].equals(e)){
                return true;
            }
        }
        return false;
    }

    /**
     * 删除指定索引上的元素
     * @param index
     * @return
     */
    public E remove(int index){
        if (index<0||index>=size){
            throw new RuntimeException("索引值不符合规范");
        }
        E e=data[index];
        for (int i=index+1;i<size;i++){
            data[i-1]=data[i];
        }
       size--;
         //在进行完上面的操作后数组中的size索引位置依然有值，将其设置为null进行垃圾回收
        data[size]=null;
        return  e;
    }
}

6.动态数组的实现

在我们之前设计的数组中，数组的容量是固定的，一旦用户添加元素达到容量上限的时候会抛出异常，这里我们要进行改良，当容量达到上限的时候对数组的容量进行扩充，这里采用ArrayList中的扩容因子，为0.5，就是说当数组容量达到上限时候，在创建一个新的数组，容量为原来的1.5倍，并将原数组中的元素遍历存储到新的数组中，并将原数组的引用指向新的数组，这样就实现了数组的扩容，同样，当用户在进行remove操作的时候，当数组中的元素个数为容量的四分之一的时候需要对数组进行缩容，将容量变为原来的一半。

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

7.完整代码


public class Array<E> {
    //因为数组的长度也就是我们这个数组的容量大小，所以这里就少维护一个变量
    private E[] data;
    //数组中的元素个数
    private int size;

    /**
     * 用户在创建类的时候传入该数组的容量大小
     * @param capacity
     */
    public Array(int capacity){
        //因为java中不支持直接创建泛型的数组，所以先创建一个object类型的数组，然后再强转为泛型数组
        data = (E[])new Object[capacity];
        size=0;
    }

    /**
     * 如果用户在创建的时候不传入参数，则调用有参构造函数，并将容量默认设置为10
     */
    public Array(){
        this(10);
    }

    /**
     * 查询数组的容量大小
     * @return
     */
    public int getCapacity(){
        return data.length;
    }

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

    /**
     * 向数组的尾部添加一个元素
     * @param e
     */
    public void addLast(E e){
      add(size,e);
    }

    /**
     * 向数组的头部添加一个元素
     * @param e
     */
    public void addFirst(E e){
        add(0,e);
    }

    /**
     * 向数组的任意位置添加一个元素
     * @param index
     * @param e
     */
    public void  add(int index ,E e){
        if (size==data.length){
//            throw new RuntimeException("数组容量已满");
            resize(data.length/2+data.length);
        }

        if(index<0|| index>size){
            throw new RuntimeException("索引值不符合要求");
        }

        for (int i=size-1;i>=index;i--){
            data[i+1]=data[i];
        }
        data[index]=e;
        size++;
    }

    @Override
    public String toString() {
        StringBuffer stringBuffer=new StringBuffer();
        stringBuffer.append("数组的元素的个数为"+size+"\r\n"+"数组的容量为"+data.length+"\r\n");
        stringBuffer.append("[");
        for (int i=0;i<size;i++){
            stringBuffer.append(data[i]);
            if (i!=size-1){
                stringBuffer.append(",");
            }
        }
        stringBuffer.append("]");
        return stringBuffer.toString();
    }

    /**
     * 获取指定索引上的元素
     * @param index
     * @return
     */
    public E get(int index){
        if (index<0||index>size){
            throw  new RuntimeException("索引值不符合要求");
        }
        return data[index];
    }

    /**
     * 修改指定索引上的元素
     * @param index
     * @param e
     */
    public void set(int index , E e){
        if (index<0||index>=size){
            throw  new RuntimeException("索引值不符合要求");
        }
        data[index]=e;
    }

    /**
     * 查询传入的元素在数组中的索引，如果该元素不存在则返回-1
     * @param e
     * @return
     */
    public int find(E e){
        boolean b = contain(e);
        if (b){
            for (int i=0;i<size;i++){
                if (data[i].equals(e)){
                    return i;
                }
            }
        }
        return -1;
  }

    /**
     * 查看数组中是否包含某个元素，如果包含返回true，否则返回false
     * @param e
     * @return
     */
    public boolean contain(E e){
        for (int i=0;i<size;i++){
            if (data[i].equals(e)){
                return true;
            }
        }
        return false;
    }

    /**
     * 删除指定索引上的元素
     * @param index
     * @return
     */
    public E remove(int index){
        if (index<0||index>=size){
            throw new RuntimeException("索引值不符合规范");
        }
        E e=data[index];
        for (int i=index+1;i<size;i++){
            data[i-1]=data[i];
        }
       size--;
        //在进行完上面的操作后数组中的size索引位置依然有值，将其设置为null进行垃圾回收
        data[size]=null;
        if (size<=data.length/4){
            resize(data.length/2);
        }
        return  e;
    }

    /**
     * 数组的扩容和缩容操作
     * @param newCapacity
     */
    private void resize(int newCapacity){
        E[] newData=(E[])new Object[newCapacity];
        for (int i=0;i<size;i++){
            newData[i]=data[i];
        }
        data=newData;
    }
}
星空茶
关注
  • 3
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
Java基础——数组
D_ar_ker的博客
02-18 1173
Java基础中数组的学习，包含数组的定义及使用还有数组的存储结构
使用java数组 封装自己的数组操作示例
08-24
"使用Java数组封装自己的数组操作示例" 本文主要介绍了使用Java数组封装自己的数组操作，结合实例形式分析了Java数组索引、遍历等相关封装操作技巧与注意事项。 一、Java数组的基本概念 Java数组是一种基本的数据...
Java数组
xinhang10的博客
10-22 7138
此文章对Java中的数组进行了详细的讲解，从数组的定义、创建到使用，以后数组如何传参，数组作为方法返回值应该怎么做。为了防止大家看不懂，我们特地的为大家准备了一些例题，如数组转字符串、数组拷贝、找数组中的最大元素、找数组的平均值、查找数组中的指定元素(二分法和顺序查找)、检索数组的优秀给你、数组排序、数组逆序、以及数组数字排列。在文章的最后，我们为大家讲解了二位数组是什么它怎么遍历，等……
Java数组（这一篇就够了）（超详细）
最新发布
m0_73158088的博客
03-21 6460
文字定义：数组是一种数据结构，用于存储多个相同类型的数据。java中 "类型[ ]" 即数组，并且索引下标从0开始。
C++以数组类封装巩固C++基础知识
sad_liu的博客
03-25 142
C++数组类封装
JAVA基础知识三——数组&封装&继承&构造器
Fighting0429的博客
05-10 358
1.2、数组的初始化 初始化的作用：数组只有初始化之后才有数值，才能使用。且只有初始化，JAVA系统才会给数组分配存储空间。 1.2.1、动态初始化 注意： 1.2.2、静态初始化 1.3、数组元素的引用 数组元素可以单独引用，也可以循环遍历使用。 1.4、Java中的内存分配 1.4.1、数组占用的存储空间 1.5、数组操作常见的两个小问题 2、数组的排序 3、方法的概述 4、方法的重载 ...
Java封装数组之动态数组实现方法详解
08-24
Java封装数组之动态数组实现方法详解 Java中的动态数组是一种可以自动扩充容量的数组，它可以根据实际情况动态地调整数组的大小。本文将详细介绍Java中动态数组的实现方法，包括定义核心扩容方法、改进之前的数组...
Java封装数组之添加元素操作实例分析
08-24
Java封装数组之添加元素操作实例分析 本文主要介绍了Java封装数组之添加元素操作，结合实例形式分析了Java封装数组实现元素追加、插入等相关操作技巧。下面是本文的知识点总结： 1. 向所有元素后添加一个元素 在...
Java针对封装数组的简单复杂度分析方法
08-24
Java针对封装数组的简单复杂度分析方法主要介绍了Java针对封装数组的简单复杂度分析方法，简单讲述了java封装数组时间复杂度分析的原理、实现方法与操作注意事项。时间复杂度分析是衡量算法执行效率的重要指标，它...
Java封装数组之改进为泛型数组操作详解
08-24
Java 封装数组之改进为泛型数组操作是 Java 语言中的一种重要技术，旨在将基本类型数组封装为泛型数组，以提供多种类型数组的操作。下面将对 Java 封装数组之改进为泛型数组操作进行详细讲解。 一、泛型数组相关...
java封装数组类
NEOSONG
10-08 3344
学习数据结构，自己实现了一些数组的基本操作，里面可能会有错误，还望指正 对数组的封装操作，类似于线性表中的顺序存储 /** * @author NeoSong * @date Oct 8, 2017 * 5:44:10 PM * program OF information: 1.自定义类MyArray来封装数组类 * 2.定义操作数组类的方法
java对数组封装_java中的数组 和 封装
weixin_35315373的博客
02-13 359
packagecom.aaa.zxf;/*** 一、 普通java项目 导入测试类的方法。* ideal 中 java 项目中导入测试类的方法 手动写入* import org.junit.Test** alt + ent 导入Junit 的工具包 。*/importorg.junit.Test;importjava.io.Serializable;/*** ...
一、数组的封装
JenKin的博客
05-18 2974
数组首先本身就是一个数据结构，在Java中ArrayList就是一个基于数组而实现的非常好用的工具，这里我就是对数组实现了一些简单的封装，让我们的数组拥有了一些简单的增删改查的功能。 源码贴出~package com.array;/** * java数据结构与算法----数组 * 数组本身就是一种数据结构，这里是对数组的简单封装 * @author ** * */ public clas
Java基础 封装 构造方法 数组
lsp的博客
07-16 1966
return continue break区别  continue结束本次 继续下次循环  return用于终止方法的执行   用在循环语句中return break作用相似 了解封装的概念 不封装的时候又会有什么问题  private 例子 class Person //自定义一个类 { //定义属性 private String name; //定义姓名 private ...
java对数组封装_Java 中对数组进行封装
weixin_39658726的博客
02-13 179
package test2;//import java.util.*;public class Test {private int array[];private int nElements;public Test(int max){array = new int[max];nElements = 0;}public boolean insert(int value){if(nElements &...
Java学习，数组的相关操作，封装类，Class类，反射API
WiZiM404.COM
02-13 1903
数组相关操作：在Java中，使用例如：int[] a=int[10]={1,2,3,4,5,6,7,8,9,0};来创建数组。所有的数组都有一个缺省的属性length，用于获取数组中元素的个数。数组的复制：System.arraycopy()。数组的排序：Arrays.sort()。在已排序的数组中查找某个元素：Arrays.binarySearch()。 封装类：每一种基本数
JAVA学习笔记（四）数组 方法 对象 封装
JChalice的博客
11-24 252
多个数组指向相同 int[] arr=new int[3]; arr[0]=100; arr[1]=200; arr[2]=300; System.out.println(arr); System.out.println(arr[0]); System.out.println(arr[1]); System.out.println(arr[2]); //定义第二个数组指向第一个数组 int[] arr2=arr; arr2[0]=111; arr2[1]=222; arr2[2]=333; //此时第一个数
【JS】JavaScript中的数组方式封装(包括两种sort写法)
a1611107035的博客
11-04 872
在JavaScript的ES6中新增了一些十分有用的数组遍历方式。尽管他们特别重要，但他们本质上都是语法糖。也就是说，我们可以比较轻松地封装我们自己的数组方式。本文将从forEach， map，filter，和every开始，到最后使用两种种方式封装数组排序的方法
Java 数组 Array 二次封装
Andy86869的博客
04-25 471
&gt;&gt;点击领取阿里云优惠券&lt;&lt; 数组是基本的数据结构 , 在 Java 语言中也比较常用 , 但是 Java提供的Array 数组, 有诸多不便, 并且也是静态数组, 刚好最近研究了一下数据结构, 将Array 封装了一下 , 代码如下 /** * Created by Lucas Ma Date:2018/4/24 * Java 数组的二次封装 */ pub...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值