一、数组

• 数组是相同类型数据的有序集合。
• 数组描述的是相同类型的若干个数据，按照一定的先后顺序排列组合而成。
• 每个数据称作一个数组元素，每个数组元素可以通过一个下标访问。

二、数组声明创建

• 首先必须声明数组变量，才能在程序中使用数组。

dataType[] arrayRefVar; //首选方法
or
dataType arrayRefVar[];

• Java使用new操作创建数组。

dataType[] arrayRefVar = new dataType[arraysize];

• 数组的元素是通过索引访问的，数组索引从0开始。
• 获取数组长度：array.length

package com.Li.array;

public class Demo {
    //变量类型   变量的名字 = 变量的值;
    //数组类型

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

• 数组边界问题

1. 小标的合法区间：[0,length-1],越界就会报错。

public class Demo3 {
    public static void main(String[] args) {
        int[] a = new int[2];
        System.out.println(a[2]);
    }
}

2. ArrayIndexOutOfBoundsException：数组小标越界异常。

三、数组使用

1、普通for循环

package com.Li.array;

public class Demo3 {
    public static void main(String[] args) {
        int[] a = {1,2,3,4,5};
        //打印全部数组的值
        for (int i = 0; i< a.length; i++){
            System.out.println(a[i]);
        }
        //计算所有元素的和
        System.out.println("===============");
        int sum = 0;
        for(int i = 0; i< a.length; i++){
            sum = sum + a[i];
        }
        System.out.println("sum:"+sum);
        System.out.println("===============");
        //查找最大元素
        int max = a[0];
        for (int i = 0; i <a.length ; i++) {
            if(a[i]>max){
                max = a[i];
            }
        }
        System.out.println(max);
    }
}

2、For-Each循环

        int[] a= {1,2,3,4,5,6};
		//JDK1.5 没有下标
        for (int i : a) {
            System.out.println(i);
        }

3、数组作方法入参

     //打印数组元素
    public static void printArray(int[] arrays){
        for (int i = 0; i <arrays.length ; i++) {
            System.out.println(arrays[i]+"");
        }
    }

4、数组作返回值

    //反转数组
    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;
    }

四、多维数组

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

int a[][] = new int[2][5]; //可以看成一个2行5列的数组

package com.Li.array;

public class Demo5 {
    public static void main(String[] args) {
        //[4][2]
        /*
            1,2 array[0]
            3,4 array[1]
            5,6 array[2]
            7,8 array[3]
        */
        int[][] array ={{1,2},{3,4},{5,6},{7,8}};
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.println(array[i][j]);
            }
            
        }
    }
}

五、Arrays类

常用Arrays类的方法可常看java帮助文档。

package com.Li.array;

import java.util.Arrays;

public class Demo6 {
    public static void main(String[] args) {

        int[] a = {1,2,5484,1546,1546,5,46,4};
        System.out.println(a);
        //打印数组
        System.out.println(Arrays.toString(a));
        System.out.println("===========");

        //对数组进行排序
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));

        //数组填充
        Arrays.fill(a,2,5,0);
        System.out.println(Arrays.toString(a));
    }
}

六、稀疏数组

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

1. 记录数组一共几行几列，有多少个不同值
2. 把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模

• 如下图，左边为原始数组，右边为稀疏数组。

package com.Li.array;

public class Demo8 {
    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;
        //输出原始数组
        System.out.println("输出原始数组：");

        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }

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

        //转换为稀疏数组保存
        //获取有效值的个数
        int sum = 0;
        for (int i = 0; i <array1.length ; i++) {
            for (int j = 0; j < array1[i].length ; 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]];

        //2、给其中的元素还原它的值
        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+"\t");
            }
            System.out.println();
        }
    }
}

运行结果：