Java6——数组、查找和排序

发布于2024.7.15

数组

是一种引用数据类型，数组型数据是对象。

第一种动态分配：

        int hen[] = new int[5];
        int[] a = new int[5];

第二种动态分配（先声明后定义）：

        int a1[];
        int[] a2;// 此时该数组为 null
        a1 = new int[10];

取数组长度：

       int len = hens.length ;

静态初始化：

        double[] hens = {1,2,3,4,5};

与C++的不同之处：如果没有赋值的话，是自动给出默认值的：

数组赋值机制：

arr2得到的是arr1的地址，两者指向堆中同一块地址，所以改变arr2中的值，arr1中的值也会跟着改变。

数组的赋值（而非拷贝）：

        int[] arr1 = {10,20,30};
        int[] arr2 = new int[arr1.length];
        for(int i = 0; i < arr1.length; i++){
            arr2[i] = arr1[i];

 关键在于要new一个新的空间。

当已有值的arr1再给其拷贝赋值arr1=arr2时：

如上，基于Java的垃圾自动回收机制，我们可以用以下代码实现数组的扩容：

        int[] arr1 = {10,20,30};
        int[] arrNew = new int[arr1.length + 1];
        for(int i = 0; i < arr1.length; i++){
            arrNew[i] = arr1[i];
        }
        arrNew[arr1.length + 1] = 40;
        arr1 = arrNew;
        for(int i =0; i < arr1.length; i++){
            System.out.print(arr1[i] + " ");
        }

排序

冒泡排序：

        int[] arr = {20,49,39,48,59,20,49,38,59,48,59,49};
        boolean isSwap;//默认值为false
        for(int i = 0; i < arr.length - 1; i++){
            //为什么是length - 1: 因为数字不需要和自己比较。
            isSwap = false;
            for(int j = 0; j < arr.length - i - 1; j++){
                if(arr[j] < arr[j+1]){
                    int tmp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = tmp;
                    isSwap = true;
                }
            }
            if(isSwap == false){
                break;
            }
        }
        for(int i = 0; i < arr.length; i++){
            System.out.print(arr[i] + " ");
        }

查找

多维数组—二维数组

应用：

        //另外的一种定义方法：
        String strs[] = new String[]{"a","b","c"};
        //但是此处String中括号内不可以有数字。

        //二维数组三种声明方式
        int[][] a1;
        int[] a2[];
        int a3[][];

        //静态初始化：
        int[][] twoDimensionalArr = {{20,49},{39,48},{59,20},
                {49,38},{59,48},{59,49}};

        //动态初始化1：
        int arr[][];
        arr = new int[2][3];

        //动态初始化2：
        int[][] a = new int[2][3];

        for(int i = 0; i < twoDimensionalArr.length; i++){
            for(int j = 0; j < twoDimensionalArr[i].length; j++){
                System.out.print(twoDimensionalArr[i][j] + " ");
            }
            System.out.println();
        }       

由于Java中，二维数组的外层数组实际上是一维数组，所以可以用以下方式来建立一个不定长的二维数组：

        //不定长数组：
        int[][] b = new int[3][];
        for(int i = 0; i < b.length; i++){
            b[i] = new int[i+1];
            for(int j = 0; j < b[i].length; j++){
                b[i][j] = i + 1;
            }
        }
        //如果没有给一维数组 new ，那么 arr[i] 就是 null
        //同样，也可以用静态初始化的方式使每个小数组不等长

 二维数组的内存布局：

第一层数组里（外层）存的仍然是地址。