Java实现自定义数组及其方法

自定义数组

主要功能有增、删（根据索引，根据值）、改、查扩容等功能

package array;

public class CustomArray {
    private int[] array = null;
    //数组有效长度
    public int length = 0;

    //空参构造函数，默认数组大小为10
    public CustomArray() {
        this.array = new int[10];
    }

    public CustomArray(int size) {
        this.array = new int[size];
    }

    //给自定义数组添加元素
    public void insert(int number) {
        //判断数组是否满
        //满了，扩容,扩容需要新建一个数组，将旧的数据复制过去，再插入
        //没满，直接插入
        //插入之后length+1
        if (length == array.length) {
            expand(this.array);
            array[length] = number;
        } else {
            this.array[length] = number;
        }
        length++;

    }

    //根据索引删除元素
    public void deleteByIndex(int index) throws Exception {
        //判断索引是否越界，即超过了有效长度
        //超过了，抛出异常提示
        //没超过就删除
            //首先需要将该索引之后的所有元素前移一个位置。
            //最后length-1
        if (index > length - 1 || index < 0) {
            throw new Exception("删除时索引越界");
        } else {
            for (int i = index; i < length; i++) {
                array[i] = array[i + 1];
            }
            length--;
        }
    }

    //根据值删除元素，删除多个
    public void deleteByValue(int value) throws Exception {
        //首先看数组中有没有这个值，没有抛异常提示
        boolean flag = false;
        for (int i = 0; i < length; i++) {
            if (array[i] == value) {
                flag = true;
                deleteByIndex(i);
            }
        }
        if (!flag)
            throw new Exception("该元素不存在");
        deleteOne(value);

    }

    //删除一个元素
    public void deleteOne(int value) throws Exception {
        boolean flag = false;
        for (int i = 0; i < length; i++) {
            if (array[i] == value) {
                flag = true;
                deleteByIndex(i);
                break;
            }
        }
        if (!flag)
            throw new Exception("该元素不存在");

    }


    //修改某索引对应元素的值
    public void update(int index, int value) throws Exception {
        if (index > length - 1 || index < 0) {
            throw new Exception("修改时索引越界");
        } else {
            array[index] = value;
        }
    }

    //（遍历）数组的元素
    public void travel() {
        System.out.print("[");
        for (int i = 0; i < length; i++) {
            System.out.print(array[i]);
            if (i < length - 1)
                System.out.print(",");
        }
        System.out.println("]");
    }

    //根据值查找元素，返回索引
    public int search(int value) throws Exception {
        int i = 0;
        for (i = 0; i < length; i++) {
            if (value == array[i])
                break;
        }
        if (i == length)
            return -1;
        return i;
    }
    //根据索引元素，返回值
    public int searchByIndex(int index) throws Exception {
        if(index<0||index>=length){
            throw new Exception("索引越界");
        }
        return array[index];

    }

    //每次扩容后比之前大一倍
    public void expand(int[] arr) {
        int expandSize = arr.length * 2;
        this.array = new int[expandSize];

        for (int i = 0; i < arr.length; i++) {
            this.array[i] = arr[i];
        }
    }


}

测试类如下：

package array;

public class ArrayTest {

    public static void main(String[] args) throws Exception {

        CustomArray array=new CustomArray();
        array.insert(10);
        array.insert(9);
        array.insert(8);
        array.insert(4);
        array.insert(5);
        array.insert(6);
        array.deleteByIndex(0);

        array.travel();
        
    }
}

自定义有序数组

主要功能有插入、二分查找递归版、二分查找非递归

package array;

public class OrderArray {
    private int[] array = null;
    //数组有效长度
    public int length = 0;

    public OrderArray() {
        this.array = new int[50];
    }

    public OrderArray(int size) {
        this.array = new int[size];
    }

    //此处有许多细节
    public void insert(int value) {

        int i;
        for (i = 0; i < length; i++) {
            if (value < array[i])
                break;
        }
        for (int j = length - 1; j >=i; j--) {
            array[j+1] = array[j];
        }
        array[i] = value;

        length++;

    }

    public void travel() {
        System.out.print("[");
        for (int i = 0; i < length; i++) {
            System.out.print(array[i]);
            if (i < length - 1)
                System.out.print(",");
        }
        System.out.println("]");
    }
    //二分查找，返回索引
    public int binarySearch(int value){
        int left=0,right=length-1;
        int mid;

        while(left<=right){
            mid=(left+right)/2;

            if(value==array[mid])
                return mid;
            if(value<array[mid]){
                right=mid-1;
            }else{
                left=mid+1;
            }
        }
        return -1;
    }
    public int binarySearchByRecursion(int value,int begin,int end){
        int mid=(begin+end)/2;

        if(array[mid]==value)
            return mid;
        if(begin>end)
            return -1;
        if(value<array[mid]){
            end=mid-1;
            return binarySearchByRecursion(value,begin,end);
        }else{
            begin=mid+1;
            return binarySearchByRecursion(value,begin,end);
        }
    }


}

测试类：

package array;

public class ArrayTest {


    public static void main(String[] args) throws Exception {

        OrderArray orderArray=new OrderArray();
        
        orderArray.insert(9);
        orderArray.insert(8);
        orderArray.insert(7);
        orderArray.insert(6);
        orderArray.insert(5);
        orderArray.travel();
        System.out.println(orderArray.binarySearch(6));
        System.out.println(orderArray.binarySearchByRecursion(6,0,orderArray.length-1));

    }

}

通过以上练习可以很好的巩固基础编码能力

冰冻三尺非一日之寒，脚踏实地埋头干