6java的数组/数组涉及的常见算法

数组

 

 

 

public class Test2 {
    public static void main(String[] args) {
        int [] a = new int[3];//使用动态初始化的时候，数组的元素有默认值，数字类型的默认值0，对象类型为null
        System.out.println(a[2]);//结果为0
        System.out.println(a.length);//数组长度为3
    }
}

public class Test2 {
    public static void main(String[] args) {
        //一维数组中每一个元素都是一个数组，这样的数组就是二维数组
        int [][] two = new int[][] {//静态初始化
            {1,2},
            {3,4}
        };
        int[][] bwt = new int[2][3];//第一维部分的长度是2，第二维也就是第一维的每个元素的长度是3
        int[][] awe = new int[2][];//只定义第一维，第二维不定义,那么第二维就是空数组,通常这种定义适用于第二维长度不一样
        awe[0]=new int[3];//定义一维的第一个元素的长度为3
        awe[1]=new int[4];//定义一维的第二个元素的长度为4
        System.out.println(awe[1].length);//4
    }
}

 练习：获取arr二维数组中所有元素的和

public class Test2 {
    public static void main(String[] args) {
        int[][] arr = new int[][]{{3,8,2},{2,7},{9,0,1,6}};//静态初始化
        int result = 0;//累加和
        for(int i = 0 ;i < arr.length ; i++) {//arr.length为一维长度
            for(int j = 0 ; j < arr[i].length ; j++) {//arr[i].length为每一个一维数组的长度
                result += arr[i][j];
            }
        }
        System.out.println(result);
    }
}

 总结：数组之间赋值，维度一定要相等，否则不通过。

数组中涉及的常见算法

 

//1.求数组元素的最大值、最小值、总和、平均数
            int a[] = new int[]{1,5,72,12,53,13,52,33,11};
            int max = a[0];//定义第一位是最大值
            for(int i = 0 ; i < a.length ; i++) {
                if(max < a[i]) {
                    max = a[i];
                }
            }
            System.out.println("max = "+max);
            //数组最小值
            int min = a[0];//定义第一位最小值
            for(int i = 0 ; i < a.length ; i++) {
                if(min > a[i]) {
                    min = a[i];
                }
            }
            System.out.println("min = "+min);
            //数组总和/平均数
            int count = 0 ; //定义累加
            int avg = 0;//平均数
            for(int i = 0 ; i < a.length ; i++) {
                count += a[i];
            }
            System.out.println("count = "+count);
            System.out.println("avg = "+(count/a.length));

    //2.数组的复制、反转 ，注意复制不是赋值，复制会新占用空间
            int arrs[] = new int[]{1,5,72,12,53,13,52,33};//原来的顺序
            int arr[] = new int[arrs.length];//arrs.length是上面arrs数组的长度
            for(int i = 0 ; i < arrs.length ; i++) {
                arr[i] = arrs[i];//把相同位置的元素赋值给新数组
            }
            //反转1
            int t = 0;//定义一个临时变量
            for(int i = 0 ; i < arrs.length/2 ; i++) {//反转只需要反转： 数组长度/2就行，因为2个数反转就算1次
                t = arrs[i];//首先数组第一个元素先赋值给一个临时变量
                arrs[i] = arrs[arrs.length-1-i];//然后把最后一位的元素赋值给第一个元素
                arrs[arrs.length-1-i] = t;//然后再把临时变量里面的第一个元素赋值给最后一个元素，完成反转
            }
            for(int i :arrs) {//增强循环打印反转后的数组
                System.out.print(i+" ");//33 52 13 53 12 72 5 1
            }
            System.out.println();
            //反转2  因为反转1已经反转过来 所以用了上面的arr复制数组
            int temp[] = new int[arr.length];//先定义一个临时数组
            for(int i =arr.length-1 ,k = 0 ; i >= 0 ; i--,k++) {//反序循环，k是临时数组的下标
                temp[k] = arr[i];
            }
            arr = temp;//循环结束后，把temp反序数组赋值给正序arrs数组
            for(int i :temp) {//增强循环打印反转后的数组
                System.out.print(i+" ");//33 52 13 53 12 72 5 1
            }

 

 这次就演示冒泡排序：

思路：

//4,7,3,1

//4,3,1,7第一轮得到一个最大的数字，放在倒数第一位

//3,1,4,7第二轮得到除最后一位数字之外的最大数字，放在倒数第二位

//1,3,4,7第三轮得到除最后两个数字之外的最大数字，放在倒数第三位

public class Test2 {
    public static void main(String[] args) {
        //3.数组元素的排序，冒泡排序
        int []arrs = new int[] {32,54,12,5};
        int t = 0 ; //临时变量
        for(int i = 0 ; i < arrs.length -1; i++) {//遍历数组的轮数，之所以-1是因为最后一轮后面没有数字可比了
            for(int j = 0 ; j < arrs.length -1 -i; j++) {//arrs.length-i-1，-1是因为下面已经j+1了，如果这里不减1，会数组越界，-i是每次比较完就减去比较的数量（简单的来说，前面第一位元素已经循环过一次放到了最后一位，不用再次循环，当然不用-i也是对的，不过会多循环几次）
                if(arrs[j]>arrs[j+1]) {//每循环一次当前元素于下一个元素比较，大的放后面位置
                    t = arrs[j];
                    arrs[j] = arrs[j+1];
                    arrs[j+1] = t;
                }
            }
        }
        for(int i : arrs) {//增强循环打印
            System.out.print(i+" ");//5 12 32 54
        }
    }
}

 

 练习：数组赋值和复制的区别

数组的赋值：

public class Test2 {
    public static void main(String[] args) {
        int array1[]= {2,3,5,7,11,13,17,19},array2[];//创建两个一位数组，并给数组1初始化
        System.out.println(Arrays.toString(array1));//打印数组1
        array2=array1;//把数组1赋值给数组2
        for(int i = 0 ; i < array2.length; i++) {//遍历数组2
            if(i % 2 == 0) {
                array2[i] = i; //把数组2的 偶  索修改位偶数  使其等于索引值
            }
        }
        System.out.println(Arrays.toString(array1));//打印数组1
        //发现修改了数组2的值，数组1的也会跟着改变
        //array1和array2的关系是：都为引用类型，当array1赋值给array2时，array2的堆内存指向了array1,因为两个数组指向了同一地址，如果值修改，两者都会有影响
    }
}

数组的复制：

public class Test2 {
    public static void main(String[] args) {
        int array1[]= {2,3,5,7,11,13,17,19},array2[] = new int[array1.length];//创建两个一位数组
        for(int i = 0 ; i < array1.length ; i++) {
            array2[i]=array1[i]; //遍历array1的值赋值给array2
        }
        for(int i = 0 ; i < array2.length; i++) {//遍历数组2
            if(i % 2 == 0) {
                array2[i] = i; //把数组2的 偶  索修改位偶数  使其等于索引值
            }
        }
        System.out.println(Arrays.toString(array1));//打印数组1
        System.out.println(Arrays.toString(array2));//打印数组2
        //发现修改了数组2的值，数组1的值没有发生改变
        //总结：数组1和数组2引用类型如果不是指向同一堆内存，那么修改其中一个数组不会对另外一个数组产生影响
    }
}

补充：如果不是很了解地址引用，可以去这里看看 java的地址：  Java内存机制和内存地址