Java（四）数组

数组：单个的数组变量可以引用一个大的数据集合，数组在内存中是若干个大小一致，类型一样，地址连续的存储空间。

数组的创建：一旦数组被创建，他的大小就是固定的，不可被改变。当创建数组后，他的元素被赋予默认值，数值型基本数据类型的默认值为0，char型的默认值为'\u0000',boolean型的默认值为false.

      1)数据类型[ ] 数组名=new 数据类型[长度];
      2)数据类型[ ] 数组名=new 数据类型[ ]{元素1,元素2,....};
      3)数据类型[ ] 数组名={元素1,元素2,....};      

 

      创建流程

     1.函数中定义变量空间并起名

     2.在堆内存中根据长度创建数组

     3.对每一个元素进行默认初始化 int->0 double->0.0 boolean->false

     4.将数组中第一个元素的地址当成整个数组的地址传递给变量

     5.变量指向该数组(引用数据类型)

数组的访问：数组元素可以通过下标访问，下标是从0开始的，对应的位置n减去1即为数组下标。

     注意：越界访问数组是经常出现的程序设计错误，它会抛出一个运行异常错误ArrayIndexOutOfBoundsException。为了避免错误的发生，在使用时应确保所使用的下标不超过arr.length - 1;

数组的遍历：

public static void bianli(){
        
        int[] arr={1,2,3,4,5,6};//首先创建一个数组
        for(int i=0;i<arr.length;i++){//正向遍历，注意是从0开始开始
            System.out.print(arr[i]+" ");
        }
        System.out.println();
        for(int i=arr.length-1;i>=0;i--){//反过来遍历
            System.out.print(arr[i]+" ");
        }
        System.out.println();
    }

数组的查找：

  1.线性查找（O(n)）适用于较小的数组或没有排序的数组中查找。

public static void find(){
        //线性查找
        //最好情况O(1)
        //最坏情况O(n)
        //平均情况O(n)
        int[] arr={3,2,1,9,5,6,8,7};
        int key=10;//找元素key的角标
        int index=-1;//如果没有找到，就返回-1
        for(int i=0;i<arr.length;i++){
            if(arr[i]==key){
                index=i;//如果找到就返回对应的下标，并退出循环
                break;
            }
        }

  2.二分查找（前提是已经排好序，时间复杂度是O(logn)）

public static int binary(){
    arr=new int[]{1,2,3,4,5,6,7,8,9};
    key=10;
    int minIndex=0;
    int maxIndex=arr.length-1;
    int midIndex=(minIndex+maxIndex)/2;
    index=-1;
    while(true){
        if(arr[midIndex]>key){ //如果中间的值大于要找的值
            maxIndex=midIndex-1;//就把中间的角标-1 赋给最大的角标
        }else if(arr[midIndex]<key){//如果中间的值小于要找的值
            minIndex=midIndex+1；//就把中间的角标+1 赋给最小的角标
        }else{
            index=midIndex;//找到的时候，就把中间角标值赋给index
            break;
        }   
        midIndex=(minIndex+maxIndex)/2;
        if(minIndex>maxIndex){//当最小角标在最大角标的右边时，证明没找到
            break;
     }
}

数组的扩容：我们知道一旦一个数组被创建出来，其大小就无法被改变，那么当数组需要扩大或者缩小时，应该怎么办呢？思想是在创建一个新的更大或更小的数组，把原数组的值赋给新数组。

 public static void resize(){
        int[] arr=new int[]{1,2,3,4,5};
        int deltSize=-2;//控制扩容的大小
        int[] newArr=new int[arr.length+deltSize];//创建新数组
        //将原先的数据放入到新数组中
        for(int i=0;i<Math.min(arr.length,newArr.length);i++){//为了避免越界，遍历小一点的数组
            newArr[i]=arr[i];
        }
        arr=newArr;//原数组指向新的数组
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+" ");
        }
       
    }

数组的排序：

 1.插入排序

public static void insertSort(){
    int[] arr={5,1,3,2,7,4,9,8,6};
    for(int i=1;i<arr.length;i++){
        int e=arr[i];
        int j=i-1;
        while(j>=0&&arr[j]>e){//第i个和它前面的比较，如果比其大，就前移
            arr[j+1]=arr[j];
            j--;
        }
        arr[j+1]=e;
    }
    for(int i=0;i<arr.length;i++){
        System.out.print(arr[i]+" ");
    }
}

2.冒泡排序

public static void bubbleSort(){
        int[] arr={5,1,3,2,7,4,9,8,6};
        //i仅仅表示轮数
        for(int i=0;i<arr.length-1;i++){
            for(int j=0;j<arr.length-i-1;j++){//每一轮，最大的数字都会浮动到最上面
                if(arr[j]>arr[j+1]){
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }

3.选择排序

 public static void selectedSort(){
        int[] arr={5,1,3,2,7,4,9,8,6};
        for(int i=0;i<arr.length-1;i++){
            for(int j=i+1;j<arr.length;j++){//从第一个元素开始，每个都和自己后面的元素比较，碰
                if(arr[i]>arr[j]){          //到比自己小的就交换
                    int temp=arr[i];
                    arr[i]=arr[j];
                    arr[j]=temp;
                }
            }
        }
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+" ");
        }
        System.out.println();
    }