Java数组

源自视频课程的本人总结，推荐课程链接

数组概述

数组是相同数据类型组成的结合；有一定顺序；可以数组小标访问

数组声明创建

1. 定义：

数据类型[] 变量名称;   //首选
或
数据类型 变量名称[];   //知道，不用

2. 用new创建数组

数据类型[] 变量名称 = new 数据类型[数组大小];

3. 数组索引从0开始访问
4. 获取数组长度：arrays.length

示例：

package array;

public class ArrayDemo01 {
    public static void main(String[] args) {
        //声明一个数组
        int[] nums;

        //创建一个大小为10的数组
        nums = new int[10];

        //声明和创建一起写
        // int[] nums = new int[10];

        //数组中每个元素赋值，默认值为int的0
        nums[0] = 1;
        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;
        for (int i = 0; i < nums.length; i++) {
            sum += nums[i];
        }
        System.out.println(sum);
    }
}

5. 内存分析
   
6. 初始化

package array;

public class ArrayDemo02 {
    public static void main(String[] args) {
        //静态初始化
        int[] a = {1,3,42,3};
        System.out.println(a[0]);  //1

        //动态初始化，含默认初始化值
        int[] b = new int[4];
        b[0] = 10;
        System.out.println(b[0] +" " + b[1]);  //10 0
    }
}

7. 数组边界：[0,array.length-1]
8. 小结：

• 数组是相同数据类型的有序结合；
• 数组也是对象，数组元素相当于对象的成员变量；
• 数组的长度是确定的，不可变的。如果越界，则报：ArrayIndexOutofBounds

数组使用

示例1：普通for循环

package array;

public class ArrayDemo03 {
    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]);
        }
        System.out.println("============");
        //计算所有元素之和
        int sum = 0;
        for (int i = 0; i < arrays.length; i++) {
            sum += arrays[i];
        }
        System.out.println("sum="+sum);
        System.out.println("===========");
        //查找最大元素
        int max = arrays[0];
        for (int i = 1; i < arrays.length; i++) {
            if (arrays[i] > max){
                max = arrays[i];
            }
        }
        System.out.println("max="+max);
    }
}

示例2：for-each循环、数组作为方法、数组作返回值

package array;

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

//        //for-each，没有小标，用于打印元素
//        for (int array : arrays) {
//            System.out.println(array);
//        }

        printArray(reverse(arrays));
    }
    //反转，带有返回值
    public static int[]  reverse(int[] array){
        int[] result =  new int[array.length];
        for (int i = 0, j = result.length-1; i < array.length; i++, j--) {
            result[j] = array[i];
        }

        return result;
    }

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

多维数组

定义：

int[][] array = new int[2][6];  //两行六列
int[][] arrays = {{2,3},{3,4}};   //两行两列

Arrays类

1. 查看JDK帮助文档
2. 常用功能：
   • 给数组元素赋值：fill
   • 对数组排序：sort，升序
   • 比较数组：equals比较元素值是否相等
   • 查找：binarySearch方法进行二分查找

示例：

package array;

import java.util.Arrays;   //导入类包

public class Array {
    public static void main(String[] args) {
        int[] a  = {2,4534,665,2,5,6,7,4535345};
//        System.out.println(a);   //[I@1b6d3586  反射
        //打印数组元素Arrays.toString()
        System.out.println(Arrays.toString(a));  //[2, 4534, 665, 2, 5, 6, 7, 4535345]
        //排序
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));  //[2, 2, 5, 6, 7, 665, 4534, 4535345]

        //填充
        Arrays.fill(a,2,4,0);
        System.out.println(Arrays.toString(a));  //[2, 2, 0, 0, 7, 665, 4534, 4535345]
    }
}

稀疏数组

1. 定义：当一个数组中的大部分元素为0，或者为同一值的数组时，可以用稀疏数组保存该数组
2. 稀疏数组的处理方式：
   • 记录数组几行几列，及格不同的值（有效值）
   • 把有效值在原数组的行列和值记录在小规模数组中。
   • 

示例：

package array;

/* 原始数组
0   0   0   22  0   0   15
0   11  0   0   0   17  0
0   0   0   -6  0   0   0
0   0   0   0   0   39  0
91  0   0   0   0   0   0
0   0   28  0   0   0   0
 */

public class ArrayDemo05 {
    public static void main(String[] args) {
        //输出原始数组
        System.out.println("输出原始数组");
        int[][] array1 = new int[6][7];
        array1[0][3] = 22;
        array1[0][6] = 15;
        array1[1][1] = 11;
        array1[1][5] = 17;
        array1[2][3] = -6;
        array1[3][5] = 39;
        array1[4][0] = 91;
        array1[5][2] = 28;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[0].length; j++) {
                System.out.print(array1[i][j]+"\t");
            }
            System.out.println();
        }

        System.out.println("===============");
        //转换为稀疏数组保存
        //1.有效数字的个数
        int sum = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[0].length; j++) {
                if (array1[i][j] != 0) {
                    sum += 1;
                }
            }
        }
        System.out.println("有效数字个数为："+sum);

        //2.创建稀疏数组
        int[][] array2 = new int[sum+1][3];   //列永远为行、列、值
        array2[0][0] = array1.length;
        array2[0][1] = array1[0].length;
        array2[0][2] = sum;

        //3.遍历原始数组
        int count = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[0].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++) {
            for (int j = 0; j < array2[0].length; j++) {
                System.out.print(array2[i][j] + "\t");
            }
            System.out.println();
        }

        System.out.println("===========");
        //还原原数组
        System.out.println("还原原数组为：");
        int[][] array3 = new int[array2[0][0]][array2[0][1]];
        //遍历稀疏数组
        for (int i = 1; i < array2.length; i++) {
            array3[array2[i][0]][array2[i][1]] = array2[i][2];
        }
        //打印还原的数组
        for (int i = 0; i < array3.length; i++) {
            for (int j = 0; j < array3[0].length; j++) {
                System.out.print(array3[i][j]+"\t");
            }
            System.out.println();
        }
    }
}