数组（SE-05）

数组

数组（Array）是有序的元素序列。 若将有限个类型相同的变量的集合命名，那么这个名称为数组名。组成数组的各个变量称为数组的分量，也称为数组的元素，有时也称为下标变量。用于区分数组的各个元素的数字编号称为下标。数组是在程序设计中，为了处理方便， 把具有相同类型的若干元素按有序的形式组织起来的一种形式。 这些有序排列的同类数据元素的集合称为数组。

数组的定义

1、数据类型[] 数组名

int[] arr;        
double[] arr;      
char[] arr;

2、数据类型 数组名[]

int arr[];
double arr[];
char arr[];

数组的动态初始化

 /*
       数组的动态初始化:
                       在初始化的时候, 需要手动指定数组的长度, 系统会为数组容器分配初始值.
       动态初始化格式:
                       数据类型[] 数组名 = new 数据类型[数组的长度];
       注意:
                       打印数组变量的时候, 会打印出数组的内存地址
       [I@4f023edb :
                       @ : 分隔符
                       [ : 当前的空间是一个数组类型
                       I : 当前数组容器中所存储的数据类型
                      4f023edb : 十六进制内存地址
    */
    public static void main(String[] args) {
        // 数据类型[] 数组名 = new 数据类型[数组的长度];
        // 通过new关键字创建了一个int类型的数组容器, 该容器可以存储5个int类型的整数, 
        //该容器被arr数组变量所记录
        int[] arr = new int[10];
        // [I@4f023edb
        System.out.println(arr);
        byte[] bArr = new byte[3];
        // [B@3a71f4dd
        System.out.println(bArr);

    }

数组元素访问

每一个存储到数组的元素，都会自动的拥有一个编号，从0开始。这个自动编号称为数组索引(index)，可以通过数组的索引访问到数组中的元素。

 /*
        数组动态初始化:
                初始化的时候, 手动指定数组长度, 系统会为数组容器分配初始值.
        数组的元素访问格式:
                数组名[索引]
                索引: 数组中数据的编号方式, 编号从0开始
                作用: 访问数组容器中的空间位置
        注意:
                数组在创建完毕后, 即使没有赋值, 也可以取出, 但取出的元素都是默认初始化值.
     */
    public static void main(String[] args) {
        int[] arr = new int[3];         // 0 1 2
        // 数组名[索引]  访问数组容器中的空间位置
        System.out.println(arr[0]);     // 0  系统自动分配的默认初始化值
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        // 数组名[索引]
        arr[0] = 11;
        arr[1] = 22;
        arr[2] = 33;
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
    }

数组的静态初始化

/*
        数组静态初始化 : 初始化时指定每个数组元素的初始值，由系统决定数组长度
        完整格式:
                    数据类型[] 数组名 = new 数据类型[]{数据1,数据2,数据3...};
        简化格式:
                    数据类型[] 数组名 = {数据1,数据2,数据3...};
     */
    public static void main(String[] args) {
        // 数据类型[] 数组名 = new 数据类型[]{数据1,数据2,数据3...};
        int[] arr = new int[]{11,22,33};
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        // 数据类型[] 数组名 = {数据1,数据2,数据3...};
        int[] arr2 = {44,55,66};
        System.out.println(arr2);
        System.out.println(arr2[0]);
        System.out.println(arr2[1]);
        System.out.println(arr2[2]);

    }

数组操作的常见异常

索引越界异常

public static void main(String[] args) {
        int[] arr = new int[3];
        System.out.println(arr[3]);
}
数组长度为3，索引范围是0~2，但是我们却访问了一个3的索引。
程序运行后，将会抛出ArrayIndexOutOfBoundsException 数组越界异常。

空指针异常

 public static void main(String[] args) {
        int[] arr = new int[5];
        //把null赋值给数组
        arr = null;
        System.out.println(arr[0]);
}
arr = null 这行代码，意味着变量arr将不会在保存数组的内存地址，也就不允许再操作数组了，
因此运行的时候会抛出 NullPointerException 空指针异常。

数组遍历

 public static void main(String[] args) {
	    //定义数组
	    int[] arr = {1, 1, 3, 4, 5};
	    //使用通用的遍历格式
	    for(int i=0; i<arr.length; i++) {
	         System.out.println(arr[i]);
	    }
}

获取数组中的最大值

这种方法可以求多个数字中的最大值

public static void main(String[] args) {
        int[] arr = {1,6,0,100,25};
        // 1. 假设数组中的第一个元素为最大值
        int max = arr[0];
        // 2. 遍历数组, 获取每一个元素, 准备进行比较
        for(int i = 1; i < arr.length; i++){
            // 3. 如果比较的过程中, 出现了比max更大的, 让max记录更大的值
            if(arr[i] > max){
                max = arr[i];
            }
        }
        //  4. 循环结束后, 打印最大值.
        System.out.println("max:" + max);
}

应用-删除排序数组中的重复项

	public static void main(String[] args) {
        int[] nums = {1,6,0,100,25,1,6};
        removeDuplicates(nums);

    }
    public static int removeDuplicates(int[] nums) {
        int n = nums.length;
        if (n == 0) {
            return 0;
        }
        int fast = 1, slow = 1;
        while (fast < n) {
            if (nums[fast] != nums[fast - 1]) {
                nums[slow] = nums[fast];
                ++slow;
            }
            ++fast;
        }
        return slow;
    }

二维数组

二维数组本质上是以数组作为数组元素的数组，即“数组的数组”，类型说明符 数组名[常量表达式][常量表达式]。二维数组又称为矩阵，行列数相等的矩阵称为方阵。对称矩阵a[i][j] = a[j][i]，对角矩阵：n阶方阵主对角线外都是零元素。

二维数组动态初始化

 /*
        动态初始化格式：
            数据类型[][] 变量名 = new 数据类型[m][n];
            m表示这个二维数组，可以存放多少个一维数组
            n表示每一个一维数组，可以存放多少个元素
     */
    public static void main(String[] args) {
        // 数据类型[][] 变量名 = new 数据类型[m][n];
        int[][] arr = new int[3][3];
        System.out.println(arr);
        /*
            二维数组存储一维数组的时候, 存储的是一维数组的内存地址
         */
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        System.out.println(arr[0][0]);
        System.out.println(arr[1][1]);
        System.out.println(arr[2][2]);
        // 向二维数组中存储元素
        arr[0][0] = 11;
        arr[0][1] = 22;
        // 从二维数组中取出元素并打印
        System.out.println(arr[0][0]);
        System.out.println(arr[0][1]);

二维数组静态初始化

	/*
        完整格式：数据类型[][] 变量名 = new 数据类型[][]{ {元素1, 元素2...} , 
        {元素1, 元素2...} ...};
        简化格式: 数据类型[][] 变量名 = { {元素1, 元素2...} , {元素1, 元素2...} ...};
     */
    public static void main(String[] args) {
        int[] arr1 = {11,22,33};
        int[] arr2 = {44,55,66};
        int[][] arr = {{11,22,33}, {44,55,66}};
        System.out.println(arr[0][2]);
        int[][] array = {arr1,arr2};
        System.out.println(array[0][2]);
    }

二维数组遍历

public static void main(String[] args) {
        int[][] arr = {{11, 22, 33}, {33, 44, 55}};
        // 1. 遍历二维数组，取出里面每一个一维数组
        for (int i = 0; i < arr.length; i++) {
            //System.out.println(arr[i]);
            // 2. 在遍历的过程中，对每一个一维数组继续完成遍历，获取内部存储的每一个元素
            //int[] temp = arr[i];
            for (int j = 0; j < arr[i].length; j++) {
                System.out.println(arr[i][j]);
            }
        }
    }

面试题- 二维数组中的查找

	/**
	在一个 n * m 的二维数组中，每一行都按照从左到右递增的顺序排序
	，每一列都按照从上到下递增的顺序排序。请完成一个高效的函数，
	输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
	*/
	public static void main(String[] args) {
        int[][] matrix = {
                {1, 4, 7, 11, 15},
                {2, 5, 8, 12, 19},
                {3, 6, 9, 16, 22},
                {10, 13, 14, 17, 24},
                {18, 21, 23, 26, 30}};
        System.out.println(findNumberIn2DArray(matrix,4));
    }
    public static boolean findNumberIn2DArray(int[][] matrix, int target) {
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
            return false;
        }
        int rows = matrix.length, columns = matrix[0].length;
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < columns; j++) {
                if (matrix[i][j] == target) {
                    return true;
                }
            }
        }
        return false;
    }