目录

一 数组概述

二 数组声明创建

三 数组使用

四 多维数组

五 Arrays类

六 稀疏数组

一 数组概述

        数组的定义：相同类型数据的有序集合。每一个数据称为一个数组元素，可以通过下标来访问它们。

二 数组声明创建

        （1）首先必须声明数组变量，才能在程序中使用数组。声明变量的语法：

dataType[ ]  arrayRefVal; //首选方法
//或
dataType  arrayRefVal [ ]; //效果相同，但不是首选方法

        （2）Java语言使用 new 操作符来创建数组，语法如下：

dataType[] arrayRefVal = new dataType[ arraySize];

        注意：数组的元素是通过索引访问的，数组索引从0开始； 或许数组长度： arrays.length

public class Demo01 {
    public static void main(String[] args) {
        int[] nums; //1 声明一个数组
        nums = new int[10]; //2 创建一个数组
        nums[0] = 1;//3 给数组赋值
        nums[1] = 2;
        nums[2] = 3;
        nums[3] = 4;
        nums[4] = 5;
        nums[5] = 6;
        nums[6] = 7;
        nums[7] = 8;
        nums[8] = 9;
        nums[9] = 10;
        //计算所有元素的值
        int sum = 0;
        //获取数组长度 nums.length
        for (int i = 0; i < nums.length; i++) {
            sum = sum + nums[i];
        }
        System.out.println(sum);
        System.out.println(nums[0]);
    }
}

        三种初始化方法及内存分析

                java内存分析：

                （1）堆：存放new的对象和数组；可以被所有的线程共享，不会存放别的对象引用。

                （2）栈：存放基本变量类型（会包含这个基本类型的具体数值）；引用对象的变量（会存放这个引用在堆里面的具体地址）

                （3）方法区：可以被所有的线程共享；包含了所有的class和static变量；

                定义并创建一个数组的过程：

                        （1）定义数组后，会在栈中压入一个array元素（2）在创建数组时会在堆中开辟一块内存。（3）给数组赋值，给堆中的数组内存地址赋值。

      三种初始化：

（1）静态初始化

int[] a = {1,2,3};
Man[] mans = {new Man(1,1), new Man(2,2) }

(2)动态初始化

int[] a = new int[2];
a[0] = 1;
a[1] = 2;

        数组的默认初始化：数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化.

public class Demo02 {
    public static void main(String[] args){
        //1 静态初始化：创建+赋值
        int[] a = {1,2,3,4,5,6,7};
            //假设Man是一个类,对引用类也可以进行静态初始化
        Man[] mans = {new Man(),new Man()};
        //2 动态初始化,动态初始化时，每个元素都有一个默认初始化赋值。
        int[] b = new int[10];
        b[0] = 1;
        System.out.println(b[1]);//会输出默认初始化的值
        System.out.println(b[0]);//会输出动态初始化的值
    }
}

        数组的四个基本特点：

                数组的长度时确定的，一旦被创建，它的大小就是不可改变的。

                元素必须是相同类型，不允许出现混合类型。

                数组中的元素可以是任何数据类型，包括基本类型和引用类型。

                数组变量属于引用类型时，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。

注意：数组本身就是对象，Java中对象是在堆中，因此数组无论保存原始类型还是其他对象累心，数组对象本身就是在堆中的。

        数组边界：下标的合法区间 【0，length-1】，

如果越界就会报错：ArrayIndexOutOfBoundsException----数组下标越界异常！

三 数组使用

        数组的使用：For-Each循环；数组作方法入参；数组作返回值。

例题1 定义数组并输出所有元素、输出元素的和、输出元素中最大的值

public class Demo03 {
    public static void main(String[] args) {
        //定义数组并输出
        int[] arrays = {1, 2, 3, 4, 5};
        for (int i = 0; i < arrays.length; i++) {
            System.out.println(arrays[i]);
        }
            //第二种输出方式,增强型for循环
        for(int x:arrays){
            System.out.println(x);
        }
        //计算数组内元素的和
        int sum = 0;
        for (int i = 0; i < arrays.length; i++) {
            sum = sum + arrays[i];
        }
        System.out.println(sum);
        //返回数组内最大的值
        int max = arrays[0];
        for (int i = 0; i < arrays.length; i++) {
            max = max > arrays[i] ? max : arrays[i];
        }
        System.out.println(max);
    }
}

其他例题：---数组作为方法的参数；数组作为方法的返回值

public class Demo03 {
    public static void main(String[] args) {
        //定义数组并输出
        int[] arrays = {1, 2, 3, 4, 5};
        //数组作方法入参
        printarr(arrays);
        System.out.println("------数组作方法入参--------");
        //返回指为数组--反转数组
        int[] ans = reverse(arrays);
        printarr(ans);
        System.out.println("------返回指为数组--反转数组--------");
    }

    //数组作方法入参的方法
    public static void printarr(int[] arrays) {
        for (int x : arrays) {
            System.out.println(x);
        }
    }

    //返回指为数组--反转数组
    public static int[] reverse(int[] arrays) {
        int[] ans = new int[arrays.length];
        for (int i = 0, j = arrays.length - 1; i < arrays.length; i++, j--) {
            ans[j] = arrays[i];
        }
        return ans;
    }
}

四 多维数组

        多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，它的每个元素都是一个一维数组。

        例如 二维数组：int a[ ] [ ] = new int [2][5];

多维数组的定义及输出：

public class Demo04 {
    public static void main(String[] args) {
        int[][] array = {{1, 2}, {3, 4}, {5, 6}, {7, 8}};
        System.out.println("数组长度:" + array.length);
        System.out.println(array[0][0]);

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

    }
}

五 Arrays类

        数组的工具类java.util.Arrays

        Arrays类中的方法都是static修饰的静态方法，在使用时可以直接使用类名进行调用。

        具有以下常用功能：

           （1）给数组赋值：通过fill方法

           （2）对数组排序：通过sort方法，按升序；

              （3） 比较数组：通过equals方法比较数组中元素值是否相等。

        （4）查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作。

public class Demo05 {
    public static void main(String[] args){
        int a[] = {1,5,2,4,7,8,3,9};
        Arrays.sort(a);//调用Arrays的sort方法
        System.out.println(Arrays.toString(a));//调用Arrays的toString方法
        Arrays.fill(a,0);//调用Arrays的fill方法，将数组a全部重置为0；
        System.out.println(Arrays.toString(a));
        Arrays.fill(a,2,5,1);//调用Arrays的fill方法，将数组a的下标2到下标5全部重置为1
        System.out.println(Arrays.toString(a));
    }
}

        冒泡排序：     

        两层循环，外层冒泡轮数，里层依次比较。时间复杂度O(n2)

        1 比较相邻的元素。如果第一个比第二个大，就交换他们两个。

        2 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。

        3 针对所有的元素重复以上的步骤，除了最后一个。

        4 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

public static void sort_1(int[] array) {
        for (int i = 0; i < array.length - 1; i++) {
            for (int j = 0; j < array.length - i - 1; j++) {
                if (array[j] > array[j + 1]) {
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(array));
    }

六 稀疏数组

        稀疏数组：当一个数组中大部分元素为0，或者为同一值的数组时，可以使用稀疏数组来保存该数组。

        稀疏数组的处理方式是：（1）记录数组一共有几行几列，有多少个不同值。（2）把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模。

例如：一个5行6列的数组中有2两个有效数字，则可以表示为一个二维数组，a【0】={5，6，2}，表示原数组的行列数及有效数字数。a[1] = {n,m,66} 表示第n行第m列数字为66.

        棋盘棋子举例：

public class Demo07 {
    public static void main(String[] args) {
        //1.1 创建一个二维数组 11*11， 0：没有棋子 1：黑棋 2：白棋
        int[][] arrays1 = new int[11][11];
        arrays1[1][2] = 1;
        arrays1[4][6] = 2;
        //1.2输出原始数组
        System.out.println("输出原始数组：");
        for (int[] ints : arrays1) {
            for (int x : ints) {
                System.out.print(x + "\t");
            }
            System.out.println();
        }
        //2.1转换为稀疏矩阵保存
        //2.2获取有效值的个数
        int sum = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (arrays1[i][j] != 0) {
                    sum++;
                }
            }
        }
        //2.3创建稀疏矩阵
        int[][] array2 = new int[sum + 1][3];
        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;
        //2.4遍历二维数组，将非零值存放稀疏数组中
        int count = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (arrays1[i][j] != 0) {
                    count++;
                    array2[count][0] = i;
                    array2[count][1] = j;
                    array2[count][2] = arrays1[i][j];
                }
            }
        }
        //2.5输出稀疏数组
        System.out.println("输出稀疏数组：");
        for (int[] ints : array2) {
            for (int x : ints) {
                System.out.print(x + "\t");
            }
            System.out.println();
        }
        //3.1还原稀疏矩阵
        int[][] array3 = new int[array2[0][0]][array2[0][1]];
        //3.2给其他的元素还原值
        for (int i = 1; i < array2.length; i++) {
            array3[array2[i][0]][array2[i][1]] = array2[i][2];
        }
        //3.2输出还原后的矩阵
        for (int[] ints : array3) {
            for (int x : ints) {
                System.out.print(x + "\t");
            }
            System.out.println();
        }
    }
}