不可变数组的探究

数组

1.数组的基本使用

问题一：数组长度不可变问题，向数组中添加元素
  第一步：新建一个数组；
  第二步：将原数组中的元素依次添加到新数组中；
  第三步：把要添加的元素加到新数组的最后；
  第四步：让原数组指向新数组。

public class ArrayDemo1{
    public static void main(String[] args){
        int arr[] = new int[]{9,8,7,6};
        System.out.println(Arrays.toString(arr));
        //将其加入数组中
        int a=5;
        //创建一个新数组
        int[] newArray = new int[arr.length+1]; 
        for(int i = 0;i <= arr.length;i++){
            newArray[i] = arr[i];
        }
        newArray[arr.length] = a;
        arr = newArray;
        System.out.println(Arrays.toString(arr));
    }
}

问题二：数组元素的删除

public class ArrayDemo2{
    public static void main(String[] args){
        int[] arr = new int[]{1,2,3,4,5,6};
        //删除下标为3的元素
        int index = 3;
        int[] newArray = new int[arr.length-1];
        //这里要注意，如果i<arr.lemgth就会出现数组越界
        for(int i = 0;i<newArray.length;i++){
            if(i<index)
                newArray[i] = arr[i];
            else
                newArray[i] = arr[i+1];
        }
        arr=newArray;
        System.out.println(Arrays.toString(arr));
    }
}

2.面相对象的数组
  利用面相对象的思想，将数组和操作数组的方法封装在一个类中，通过创建类对象来实现数组的操作。

package demo1;

import java.util.Arrays;

class MyArray{
    private int[] arr;
    public MyArray(){
        arr = new int[0];
    }
    //取得数组的长度
    public int size(){
        return arr.length;
    }
    //数组末尾添加元素
    public void add(int number){
        int newArray[] = new int[arr.length+1];
        for (int i = 0;i<arr.length;i++){
            newArray[i]=arr[i];
        }
        newArray[arr.length]=number;
        arr=newArray;
    }
    //打印数组元素
    public void show(){
        System.out.println(Arrays.toString(arr));
    }
    //删除指定下标的数组元素
    public void delete(int index) {
        try {
            if (index < 0 || index >= arr.length) {
                throw new Exception("数组越界");
            }
        }catch(Exception e){
            e.printStackTrace();
        }

        int[] newArray = new int[arr.length-1];
        for (int i = 0;i<newArray.length;i++){
            if (i<index){
                newArray[i]=arr[i];
            }else{
                newArray[i]=arr[i+1];
            }
        }
        arr=newArray;
    }
    //指定位置插入元素
    public void insert(int index,int number){
        try{
            if(index<0||index>arr.length)
                throw new Exception("数组越界");
        }catch(Exception e){
            e.printStackTrace();
        }
        int[] newArray = new int[arr.length+1];
        for (int i = 0;i<newArray.length;i++){
            if (i<index){
                newArray[i]=arr[i];
            }else{
                if (i==index){
                    newArray[index]=number;
                }if (i>index)
                    newArray[i]=arr[i-1];
            }

            //newArray[index]=number;
        }
        arr=newArray;
    }
    //取出指定位置的元素
    public int  get(int index){
        try{
            if(index<0||index>arr.length)
                throw new Exception("数组越界");
        }catch(Exception e){
            e.printStackTrace();
        }
        return arr[index];
    }
    //替换指定位置元素
    public void set(int index,int number){
        try{
            if(index<0||index>arr.length)
                throw new Exception("数组越界");
        }catch(Exception e){
            e.printStackTrace();
        }
        arr[index]=number;
    }

}
public class ArrayDemo {
    public static void main(String[] args) {
        MyArray ma = new MyArray();
        System.out.println(ma.size());
        System.out.println("--------------------");
        ma.add(29);ma.add(28);
        ma.add(26);ma.add(25);
        ma.show();
        System.out.println("--------------------");
        ma.delete(3);
        ma.show();
        System.out.println("--------------------");
        ma.insert(1,1);
        ma.insert(4,25);
        ma.show();
    }
}

3.相对于数组的查找算法
1）线性查找
  就数组而言，线性查找

public class SearchDemo1{
	public static void main(String[] args){
    	//目标数组
        int[] a = new int[]{5,6,7,8,9};
        //目标元素
        int target = 9;
        int index = -1;
        for(int i = 0;i < arr.length;i++){
            if(a[i]==target){
                index = i;
                break;
            }
        }
        System.out.println("index = "+index);
    }
}

2）二分查找
  线性查找的效率较低，当数组元素是有顺序的时候，就可以使用二分法查找。

public class BinarySearch{
	public static void main(String[] args){
    	int[] a = new int[]{1,2,3,4,5,6,7,8};
        int target = 5;
        //开始位置、结束位置、中间位置
        int low = 0;int high = a.length-1;int mid =0;
        //目标位置
        int index = -1;
        //while(true){
        while(low<=high){
        	mid = (low+high)/2;
            if(a[mid]>target){
            	high=mid-1;
            }else{
            	if(a[mid]==target){
                	index=mid;
                    break;
                }else{
                	low=mid+1;
                }
            }
        }
        System.out.println("index = "+index);
    }
}