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));

     }

 }