引言

我们知道数组在使用过程中是定长的，如果当原数组满了之后，我们要存储更多元素就只能重新创建一个新的更长的数组，这样就很麻烦。而且还没办法去删除数组中的元素。那有没有一种数组可以动态存储数据呢，当我们数组元素满了，数组会自动增加空间，我们想删除那一个元素就可以删除。在Java中是有这样的存在的，那就是集合。但是他是怎么实现的呢？

怎么实现动态数组？

其实就等同于怎么去实现ArrayList集合

一、我们要实现怎样的功能

1.我们应该怎样去定义这个数组

在Java中，我们直接去操作这个数组，是没办法达到我们想要的效果的。想实现那些功能，我们可以将定义一个类，这个类产生的对象数组，那些功能可以定义成一个个成员方法，这样就可以达到我们想要的效果。
代码实现：

public class MyArray {
    private int[] data;
    private int size;//既可以表示当前数组存储了多少个元素，也可以表示当顺序存储下一个元素时，元素的索引。

    //无参构造器
    public MyArray() {
        //当用户没有规定数组的长度时，默认生成一个长度为10的数组。
        this(10);
    }

    public MyArray(int count) {
        this.data = new int[count];
    }
 }

下面就是去写这个类里面的一个个成员方法。所谓成员方法就是这个动态数组的一个个功能。
我们的目的就是去弥补我们常用数组的不足之处，那么，我们动态数组就有以下功能：

2,数组的自动扩容

当数组空间已满的时候，我们要继续去存数据，就需要给数组增加空间，所以我们可以给这个动态数组增加一个自动扩容的功能。
代码实现：

    public void grow() {
        int data[] = new int[this.data.length * 2];
        for (int i = 0; i < size; i++) {
            data[i] = this.data[i];
        }
        this.data = data;
    }

3.删除元素

a.按照索引删除，并返回删除元素的值；
b.按照元素的值删除，删除成功返回true，删除失败返回false；
c.删除数组中所有值为给定值的元素；
d.按照元素的值去删除，并返回他的索引；
e.删除第一个元素，并返回它的值
f.删除尾部元素，并返回它的值
代码实现：

   /**
     * 删除数组中索引为index的元素，并返回它的值。
     */
    public int remove(int index) {
        if (index < 0 || index > size) {
            return -1;
        }
        int a = data[index];
        for (int i = index; i < size - 1; i++) {
            data[i] = data[i + 1];
        }
        size--;
        return a;
    }

    //删除第一个元素，并返回它的值
    public int removeFirst() {
        return remove(0);
    }

    //删除尾部元素，并返回它的值
    public int removeLast() {
        return remove(size - 1);
    }

    //删除在这个数组中第一个值为val的元素，并返回他的索引；
    public int removed(int Val) {
        for (int i = 0; i < size; i++) {
            if (data[i] == Val) {
                remove(i);
                return i;
            }
        }
        return -1;
    }
        // 实现删除数组中所有值为Val的元素，并且返回他们的索引。
    public MyArray delete(int Val) {
        MyArray m2 = new MyArray();
        for (int i = size - 1; i >= 0; i--) {
            if (data[i] == Val) {
                remove(i);
                m2.add(i);
            }
        }
        return m2;
    }
        //删除在这个数组中第一个值为val的元素，并返回他的索引；
    public boolean removed1(int Val) {
        for (int i = 0; i < size; i++) {
            if (data[i] == Val) {
                remove(i);
                return true;
            }
        }
        return false;
    }

4.查找元素

a.按照索引查找
b.按照值查找
代码实现：

   /**
     * 查询一个数Val在不在数组中,在则返回true，不在则返回false。
     */
    public boolean select(int Val) {
        for (int i = 0; i < size; i++) {
            if (data[i] == Val) {
                return true;
            }
        }
        return false;
    }

    //查询一个数Val在不在数组中,在则返回他的索引
    public int selectAll(int Val) {
        for (int i = 0; i < size; i++) {
            if (data[i] == Val) {
                return i;
            }
        }
        return -1;
    }

    //查询一个索引位index的数组元素，返回它的值
    public int selected(int index) {
        if (index < 0 || index > size) {
            System.out.println("索引错误");
        }
        return data[index];
    }

5.修改元素

a.修改索引为index的元素的值为Val
b.将数组中第一个元素值为Val的值修改我Val1
代码实现：

   /**
     * 将数组中索引为index的元素的值修改为Val,并返回他原来的值。
     */
    public int amend(int index, int Val) {
        if (index < 0 || index > size) {
            System.out.println("错误");
        }
        int a = data[index];
        data[index] = Val;
        return a;
    }

    //将数组中第一个值为Val的修改成Val1,并返回他的索引;
    public int amendVal(int Val, int Val1) {
        for (int i = 0; i < size; i++) {
            if (data[i] == Val) {
                data[i] = Val1;
                return i;
            }
        }
        return -1;
    }

    //将数组中的第一个数修改为Val,并返回原来的值
    public int amendFrist(int Val) {
        return amend(0, Val);
    }

    //将数组中的最后一个数修改为Val,并返回原来的值
    public int amendLast(int Val) {
        return amend(size - 1, Val);
    }
    // :将数组中所有值为Val的元素的值修改为Val1，并且返回他们的索引。
    public MyArray reValue(int Val, int Val1) {
        MyArray m2 = new MyArray();
        for (int i = size - 1; i >= 0; i--) {
            if (data[i] == Val) {
                data[i] = Val1;
                m2.add(i);
            }
        }
        return m2;
    }

5.增加元素

代码实现：

    /**
     * index位置增加一个元素Val
     */
    public void addIndex(int index, int Val) {
        if (index < 0 || index > size) {
            System.out.println("添加位置错误");
            return;
        }
        if (size == 0) {
            data[0] = Val;
            size++;
            return;
        }
        for (int i = size; i >= index; i--) {
            if (i == index) {
                data[index] = Val;
            } else {
                data[i] = data[i - 1];
            }
        }
        size++;
        if (size == data.length) {
            grow();
        }
    }

    //在首部增加一个元素
    public void addFrist(int Val) {
        addIndex(0, Val);
    }

    //在尾部增加一个元素，默认的添加方式
    public void add(int Val) {
        addIndex(size, Val);
    }

二、toString方法的重写

在我们使用System.out.println();打印输出时，默认调用的就是toString方法，但是这个方法发在打印数组和对对象时，打印的是对象名这个变量的存储地址。因此，如果我们想使用那个方法打印一个数组，就如要对toString方法进行重写。
代码示例:

    /**
     * 重写toString方法
     */
    public String toString() {
        String ret = "[";
        for (int i = 0; i < size; i++) {
            ret += data[i];
            if (i != size - 1) {
                ret += ",";
            }
        }
        ret += "]";
        return ret;
    }

最后

以上就是听话飞机为你收集整理的Java-实现动态数组(ArrayList＜Integer＞集合)引言怎么实现动态数组？二、toString方法的重写的全部内容，希望文章能够帮你解决Java-实现动态数组(ArrayList＜Integer＞集合)引言怎么实现动态数组？二、toString方法的重写所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。