Java数组

例子：一个足球队有很多人，认识某个人的时候先是把他看作某某队的队员，然后再利用他们身上的编号去区分队员

Java中是建议在类型后面加[]代表是数组

int num[]:是C/C++语言风格的

画图工具：ProcessOn

数组就是一个对象，因为它是new出来的

public class Demo3 {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5};

        //arrays.for   增强型for循环  JDK1.5以上支持  没有下标  适合打印输出
        //arrays代表一个数组，array代表数组中的每一个元素
        for (int array : arrays) {
            System.out.println(array);
        }

    }
}

public class Demo3 {
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        
        int[] a = reverse(array);
        for (int i = 0; i <a.length ; i++) {
            System.out.println(a[i]);
        }


    }

    //反转数组
    public static int[] reverse(int[] arrays){
        int[] result = new int[arrays.length];

        //反转
        for (int i = 0, j = result.length-1; i <arrays.length ; i++,j--) {
            result[j]= arrays[i];
        }

        return result;   //Java中方法的返回值可以是数组
    }
}

Java中方法的返回值可以是数组

三维数组：

int array[3][2][2] = {0,1,2,3,4,5,6,7};//相当于3个2 * 2 的二维数组
printf("%d %d %d %d ",&array[0],&array[0][0],&array[0][0][0],&array);
//如果说把三维数组比作一个立方体的话，那么这个立方体底边是个2*2的正方形，高为3
//注意：三维数组的高维度是写在最前面的，也就是立方体的z

要研究一个类，如Arrays，在IDEA所写代码中打出Arrays，查看源码，左侧点击Structure，可以看到类中所有方法

public class Demo4 {
    public static void main(String[] args) {
        int[] a={5,9,3,7,6};
        System.out.println(a);   //[I@1b6d3586

        //打印数组元素Arrays.toString
        System.out.println(Arrays.toString(a));   //[5, 9, 3, 7, 6]

        //对数组进行排序:升序
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));   //[3, 5, 6, 7, 9]
        
        //填充
        Arrays.fill(a,2,4,0);
        System.out.println(Arrays.toString(a));   //[3, 5, 0, 0, 9]

        Arrays.fill(a,0);
        System.out.println(Arrays.toString(a));   //[0, 0, 0, 0, 0]
    }
}

//冒泡排序
//    1.比较数组中2个相邻的元素，若满足比较条件，则交换它们的位置
//    2.每一次比较都会产生出一个最大或最小的数字
//    3.则下一轮可以少一次排序
//    4.依次循环，直到结束
public class Demo5 {
    public static void main(String[] args) {
        int[] a = {5,9,3,1,7,6,2,4,2};
        int[] sort = sort(a);
        System.out.println(Arrays.toString(a));
    }




    public static int[] sort(int[] array){
        int temp = 0;

        //外层循环判断要经过几轮，一般为length-1   比较的轮数
        for (int i = 0; i <array.length-1 ; i++) {
        //比较2个数    数与数之间需要比较的次数
            for (int j = 0; j <array.length-1-i ; j++) {
                if (array[j+1]>array[j]){
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }
        }

        return array;
    }
}

public class Demo6 {
    public static void main(String[] args) {
        //1.创建一个二维数组11*11  0：没有棋子  1：黑棋  2：白棋
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;

        //输出原始的数组    array1.for
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt+"	");
            }
            System.out.println();
        }

        System.out.println("=================");

        //转换为稀疏数组保存
        //获取有效值的个数
        int sum =0;
        for (int i = 0; i <11; i++) {
            for (int j = 0; j <11; j++) {
                if (array1[i][j]!=0) {
                    sum++;
                }
            }
        }

        System.out.println("有效值个数为："+sum);


        //2.创建一个稀疏数组的数组    有效值个数+1为行数，列固定为3列
        int[][] array2 = new int[sum+1][3];

        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;

        //遍历二维数组，将非零值存放到稀疏数组中
        int count = 0;
        for (int i = 0; i <array1.length; i++){
            for (int j = 0; j <array1[i].length; j++) {
                if(array1[i][j]!=0){
                    count++;
                    array2[count][0] = i;
                    array2[count][1] = j;
                    array2[count][2] = array1[i][j];
                }
            }
        }

        //输出稀疏数组
        System.out.println("稀疏数组：");

        for (int i = 0; i <array2.length ; i++) {
            System.out.println(array2[i][0]+"	"+array2[i][1]+"	"+array2[i][2]+"	");
        }

        System.out.println("=========================");

        //还原成原数组
        System.out.println("还原：");

        //1.读取稀疏数组
        int[][] array3 = new int[array2[0][0]][array2[0][1]];

        //2.给其中的元素还原它的值
        //注意i从1开始，第0行存放的是头部信息
        for (int i = 1; i <array2.length; i++) {
            array3[array2[i][0]][array2[i][1]] = array2[i][2];
        }

        //3.打印
        System.out.println("输出还原的数组:");
        for (int[] ints : array3) {
            for (int anInt : ints) {
                System.out.print(anInt+"	");
            }
            System.out.println();
        }

    }
}