数组

数组的声明和创建

声明数组

int[ ] array = null;

创建数组

array = new int[ 10 ];

给数组元素赋值

null[ 0 ] = 1;

null[ 1 ] = 2;

null[ 2 ] = 3;

null[ 3 ] = 4;

…

多维数组的创建与取其中值

public class Array05 {
    public static void main(String[] args) {
        //创建一个数组
        //int[] b = {1,2,3,4,5,6};

        //将数组改为多维数组
        int[][] b ={{1,2},{2,3},{3,4},{4,5}};

        //取数

        System.out.println(b[0][1]);
        System.out.println(b[1][0]);
        System.out.println(b[2][1]);
        System.out.println(b[3][0]);
        Array(b[0]);//因为是多维数组  所以有一个[ ]
        //取出第一个数组中的所有元素。

    }

    //创建一个取数组中所有值的方法

    public static void Array(int[] b){
        for (int i = 0; i < b.length; i++) {
            System.out.println(b[i]+" ");

        }

    }
}

数组的冒泡排序（升序）

package array;

import java.util.Arrays;

public class Array07 {
    public static void main(String[] args) {
        //设一个数组
        int[] b = {32131,84654,12,2,3,4,978,3654,12,65,45,89};
        int[] array = array(b);//调用完我们自己写的排序方法后，返回一个排序后的数组。

        System.out.println(Arrays.toString(array));//引用了代码库的输出方法

    }
    /*
    冒泡排序
    1.比较数组中相邻的两个数，如果第一个数比第二个数大，我们就交换他们的位置
    2.每一次比较，都会产生一个最大值或者最小值。
    3.下一轮可以少一个排序。
    4.依次循环，直到结束
     */

    //外层循环：我们这个排序方法要走多少次
    public static int[] array(int[] b){
        for (int i = 0; i < b.length - 1; i++) {
            int temp = 0;
            //内层循环：比较数组中相邻的两个数大小，如果第一个数比第二个数大，我们就交换他们的位置
            for (int j = 0; j < b.length - 1 -i; j++) {
                if ( b[j] > b[j+1] ){
                    temp = b[j];
                    b[j] = b[j+1];//等号都是后值 ， 赋给前面的值。
                    b[j+1] = temp;
                }

            }

        }
        return b;
    }
}
//最后输出[2, 3, 4, 12, 12, 45, 65, 89, 978, 3654, 32131, 84654]

优化

package array;

import java.util.Arrays;

public class Array07 {
    public static void main(String[] args) {
        //设一个数组
        int[] b = {32131,84654,12,2,3,4,978,3654,12,65,45,89};
        int[] array = array(b);//调用完我们自己写的排序方法后，返回一个排序后的数组。

        System.out.println(Arrays.toString(array));//引用了代码库的输出方法

    }
    /*
    冒泡排序
    1.比较数组中相邻的两个数，如果第一个数比第二个数大，我们就交换他们的位置
    2.每一次比较，都会产生一个最大值或者最小值。
    3.下一轮可以少一个排序。
    4.依次循环，直到结束
     */

    //外层循环：我们这个排序方法要走多少次
    public static int[] array(int[] b){
        for (int i = 0; i < b.length - 1; i++) {

            boolean flag = false;//默认flag为false，如果走了循环就为ture。

            int temp = 0;
            //内层循环：比较数组中相邻的两个数大小，如果第一个数比第二个数大，我们就交换他们的位置
            for (int j = 0; j < b.length - 1 -i; j++) {
                if (b[j] > b[j + 1]) {
                    temp = b[j];
                    b[j] = b[j + 1];//等号都是后值 ， 赋给前面的值。
                    b[j + 1] = temp;
                    flag = true;
                }
            }
            //优化
            if (flag == false){
                break;
            }

        }
        return b;
    }
}

稀疏数组的使用，创建与还原

package array;

public class Array08 {
    public static void main(String[] args) {
        //定义一个二维数组   0为空白值  1为黑棋  2为白棋

        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;
        //输出原始的数组
        System.out.println("输出原始的数组:");
        //增强for循环
        for (int[] ints : array1) {    //其中array1为数组，ints为数组中所有元素
            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.创建一个稀疏数组的数组
        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] + "\t"
                    + array2[i][1] + "\t"
                    + array2[i][2] + "\t");

        }
        System.out.println("======================");
        System.out.println("还原稀疏数组：");

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

        //给其中的元素还原他的值
        for (int i = 1; i < array2.length; i++) {    //int i = 1； 从零开始取报错
            array3[array2[i][0]][array2[i][1]] = array2[i][2];

        }
        //3.打印,还原
        for (int[] ints : array3) {    //其中array3为数组，ints为数组中所有元素
            for (int anInt : ints) {
                System.out.print(anInt + "  ");

            }
            System.out.println();

        }


    }
}

总结

1. 数组就是一个数的集合，类似于小房子的东西。你可以向里面存入数值。（静态初始化数据开始设立就定死）。
2. 也可以拿出所存的数值
3. 多维数组

多维数组就是箱子里分划不同的小抽屉。能够更全面的展示

如1 2

3 4

5 6

7 8

9 10

System.out.println();

    }


}

}

# 总结

1. 数组就是一个数的集合，类似于小房子的东西。你可以向里面存入数值。（静态初始化数据开始设立就定死）。
2. 也可以拿出所存的数值
3. 多维数组[外链图片转存中...(img-J2ZOtxRG-1606642349422)]

多维数组就是箱子里分划不同的小抽屉。能够更全面的展示

如1   2

   3    4

   5    6

   7    8

   9    10



这就是二维数组的空间性。