JAVA数组

public class array_01 {
    public static void main(String[] args) {
        //动态初始化，若不进行特定赋值，则数组内元素呈默认值。int型默认0,string型默认null等
        int nums[]=new int[10]; //等号的左面是声明一个数组，右面为创建一个数组
        int sum=0;
        nums[5]=10; //赋值，但必须符合数组类型的辅助
        for (int i = 0; i <nums.length; i++) {
            sum=sum+nums[i];
        }
        System.out.println(sum);
        //静态初始化，创建+赋值
        int [] b={0,1,2,3,3,4,5,6,6,2,1};
        for (int c = 3; c < b.length; c++) {
            System.out.println(b[c]);
        }
    }}

public class array_reverse {
    public static void main(String[] args) {
        //静态初始化
        int[] arrays={0,1,2,3,4,5,6,7,8,9};
        int[] fin=reverse(arrays);
        //print_1(fin);
        print_2(fin);
        print_max(fin);

    }
    //反转数组函数
    public static int[] reverse(int[] array){

        int[] result=new int[array.length];
        for (int i = 0, j=array.length-1; i < 10;i++,j--){

            result[j]=array[i];
        }
        return result;
    }
    //输出数组各值函数1
    public static void print_1(int[] array){
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }

    }
    //输出组内各值函数2
    public static void print_2(int[] array){
        for (int array_num:array){
            System.out.println(array_num);
        }

    }

    //求组内极值函数
    public static void print_max(int[] array){
        int max=0;
        for (int i = 0; i < array.length; i++) {
            if (array[i]>max){
                max=array[i];
            }
        }
        System.out.println("组内最大值为："+max);
    }
}

//二维数组
        int[][] array={{1,2},{3,4},{5,6}};
        System.out.println(array.length);//3
        System.out.println(array[0].length);//2
        System.out.println(array[0][1]);//2

public class 冒泡排序 {
    public static void main(String[] args) {
        int[] array={4,5,85,62,32,1,3,8,1,0};
        System.out.println(Arrays.toString(paixu(array)));
    }
    //冒泡排序
    public static int[] paixu(int[] a){
        int temp=0;
        for (int i = 0; i <a.length-1; i++) {

            boolean flag=false;  //只有在发生了顺序变化时，flag为false会持续循环。否则跳出循环

            for (int j = 0; j < a.length-1-i; j++) {
                if (a[j+1]<a[j]){
                    flag=true;
                    temp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=temp;
                }
            }
            if (flag=false){
                break;
            }
        }
        return a;
    }
}

稀疏数组：若一数组中，所含大部分为0，则原有的方式较为占用空间，所以可以用稀疏数组的方式进行压缩空间。主要方法为：利用一个三维数组来记录原数组中非零值所在位置。
三维数组的方式为：
a(原数组行数) b(原数组列数) 2(非零个数)
5 6 7
8 2 3
上述表示一a行b列的稀疏数组，共有两个非零值，所在位置分别为，5行6列数值为7，8行2列数值为3.