Java数组的简单应用

本文记录Java数组的几个基本应用。

数组的初始化和遍历

数组初始化和遍历都有三种方式，参考如下代码。

import java.util.Arrays;
public class ArrayDemo{
    public static void main(String[] args){
        //定义数组的三种方式
        //方法1 动态初始化
        int[] arr1=new int[3];
        arr1[0]=1;
        //方法2 静态初始化
        int[] arr2=new int[]{1,2,3};
        //方法3 静态初始化省略写法
        int [] arr3={1,2,3};
        //遍历数组的三种方式
        //方法1 普通for循环，通过下标获取，并且可以改变数组的值
        System.out.println("-----------普通for循环-----------");
        for(int i=0;i<arr1.length;i++){
            arr1[i]*=2;
        }
        for(int i=0;i<arr1.length;i++){
            System.out.println(arr1[i]);
        }
        //方法2 增强型for循环，只能遍历数组，不能改变数组的值
        System.out.println("-----------增强型for循环-----------");
        for(int number:arr2){
            number*=2;
        }
        for(int number:arr2){
            System.out.println(number);
        }        
        //方法3 使用Arrays.toString()方法返回
        System.out.println("-----------使用Arrays.toString()方法返回-----------");
        String str=Arrays.toString(arr3);
        System.out.println(str);        
    }
}

运行结果，注意增强型for循环只能进行遍历，不能对数组内容进行修改，另外静态初始化省略的写法不能分两步写，这个需要注意下。

求数组中最值

求数组中最值一般有两种思路，一种是比较数值直接得到最值，另外一种是比较后得到索引，本次使用后者。

public class ArrayMax{
    public static void main(String[] args){
        //获取一个数组中的最大值，采用记录下标的方式
        int[] arr=new int[]{12,34,1,7,5,44,98};
        int index=0;
        for(int i=1;i<arr.length;i++){
                if(arr[i]>arr[index]){
                    index=i;
                }
        }    
        //输出最大值
        System.out.println(arr[index]);
    }
}

运行结果

冒泡排序及时间&空间复杂度

数组的排序，Java提供了现成API可以处理，如Arrays.sort()方法（底层使用了快速排序+归并排序）可以对数组进行升序排列，此外还可以使用常用的排序方式，本文再次写冒泡和选择排序，具体的参考博文 https://www.cnblogs.com/youngchaolin/p/11097567.html。

（1）冒泡排序实现

import java.util.Arrays;
public class BubbleSort{
    public static void main(String[] args){
        //冒泡排序练习
        /**
        数组相邻元素两两比较，得到最大值或最小值
        比如给一个长度为6的数组，将有如下比较逻辑：
        第1次比较，比较5次
        第2次比较，比较4次
        ...
        第5次比较，比较1次
        得到比较轮序号+比较次数=数组长度
        比较轮次：1~数组长度-1              
        第i轮比较次数：数组长度-i
        比较轮次使用外层for循环来控制，比较次数用内层for循环
        */
        int[] arr=new int[]{1,5,7,9,22,66,32,16,55,123,456};
        //降序
        for(int i=1;i<arr.length;i++){
            for(int j=0;j<arr.length-i;j++){
                if(arr[j]<arr[j+1]){
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
            System.out.println("排序后的数组为"+Arrays.toString(arr));
        }    
        /**
        时间复杂度：O(n^2) 
        比较次数即一个等差数列，去掉常数部分
        空间复杂度：o(1)
        由于创建了3个变量，因此表示为3*n^0，去掉常数3，空间复杂度为o(1)
        */
    }
}

排序过程及结果。

（2）选择排序实现

import java.util.Arrays;
public class SelectSort{
    public static void main(String[] args){
        //选择排序练习
        /**
        比较数组当前位置元素和后面所有元素，如果后面存在比当前元素大或小的，交换数值，或者使用记录下标的方式
        最后交换下标的数组，这里暂时采用前种方式
        比如给一个长度为6的数组，将有如下比较逻辑：
        第1次比较，比较5次
        第2次比较，比较4次
        ...
        第5次比较，比较1次
        得到比较轮序号+比较次数=数组长度
        比较轮次：1~数组长度-1              
        第i轮比较次数：数组长度-i
        比较轮次使用外层for循环来控制，比较次数用内层for循环
        */
        int[] arr=new int[]{1,5,7,9,22,66,32,16,55,123,456};
        //降序
        for(int i=0;i<arr.length-1;i++){
            for(int j=i+1;j<arr.length;j++){
                if(arr[i]<arr[j]){
                    //使用按位异或交换
                    arr[i]=arr[i]^arr[j];
                    arr[j]=arr[i]^arr[j];//arr[j]=arr[i]^arr[j]^arr[j]=arr[i];
                    arr[i]=arr[i]^arr[j];//arr[i]=arr[i]^arr[j]^arr[i]=arr[j];
                }
            }
            System.out.println("排序后的数组为"+Arrays.toString(arr));
        }
        /**
        时间复杂度：O(n^2) 
        比较次数即一个等差数列，去掉常数部分
        空间复杂度：o(1)
        由于创建了3个变量，因此表示为3*n^0，去掉常数3，空间复杂度为o(1)
        */
    }
}

排序过程及结果。

数组的二分查找

当数组是有序的情况，可以使用二分查找来查找某个数是否存在，其时间复杂度为O(logn)，相比来说可能比冒泡和选择排序性能更加好。

import java.util.Scanner;
import java.util.Arrays;
public class BinarySearch{
    public static void main(String[] args){
        //使用二分查找寻找一个数在数组中的位置
        /**
        如果数组是有序数组，先比较这个数和数组中中间位置（(下标左边界+下标右边界)/2）数值的大小
        1 如果恰好找到了则返回数对应下标
        2 如果比中间值大，更新数组左边界
        3 如果比中间值小，更新数组右边界
        循环上面3个步骤，继续比较，循环的条件是 下标左边界不能大于下标右边界    
        */
        System.out.println("请输入要查找的数");
        Scanner scan=new Scanner(System.in);
        int number=scan.nextInt();
        
        int[] arr=new int[]{1,5,7,9,22,66,32,16,55,123,456,88};
        //变成有序数组
        Arrays.sort(arr);
        //重新打印
        System.out.println(Arrays.toString(arr));
        int minIndex=0;
        int maxIndex=arr.length-1;
        int mid=(minIndex+maxIndex)/2;
        while(minIndex<=maxIndex){
            System.out.println("比较");
            if(arr[mid]==number){
                System.out.println("数组的下标为："+mid);
                break;
            }
            if(arr[mid]<number){
                minIndex=mid+1;//mid对应的数都不相等，mid不需要比较了，继续往右边移动一位
            }
            if(arr[mid]>number){
                maxIndex=mid-1;//mid对应的数都不相等，mid不需要比较了，继续往左边移动一位
            }
            mid=(minIndex+maxIndex)/2;
        }
        /**
        时间复杂度 O(logn)
        空间复杂度 o(1)
        */
    }
}

测试结果

总结 

以上为数组的基本知识，后续可供参考。