16、数组

数组

数组概述
- 数组是相同类型数据的有序集合。
- 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。
- 其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问他们。
数组声明创建
- 首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法：
```
dataType[] arrayRefVar; // 首选的方法 或：
dataType arrayRefVar[]; //效果相同，但不是首选方法。
```
- Java 语言使用new操作符来创建数组，语法如下：
```
   dataType[] arrayRefVar = new dataType[arraySize];
```
- 数组的元素是通过索引访问的，数组索引从0开始。
- 获取数组长度: arrays.length

Java内存分析

三种初始化

静态初始化

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

动态初始化

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

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

数组的基本特点
- 其长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
- 其元素必须是相同类型，不允许出现混合类型。
- 数组中的元素可以是任何数据类型，包括基本类型和引用类型。
- 数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其它对象类型，数组对象本身是在堆中的。
数组边界
- 索引的合法区间：[0, length-1]，如果越界就会报错；
- ArrayIndexOutOfBoundsException : 数组下标越界异常！
- 小结：
  - 数组是相同数据类型（数据类型可以为任意类型）的有序集合
  - 数组也是对象。数组元素相当于对象的成员变量
  - 数组长度是确定的，不可变的。如果越界，则报错：ArrayIndexOutOfBoundsException

数组使用

普通的for循环

public class Demo01 {
    public static void main(String[] args) {
        //创建一个整型数组
        int[] nums = {1,2,3,4,5};
        //遍历数组
        for (int i = 0; i < nums.length; i++) {
            System.out.print(nums[i] + " ");
        }
    }
}

for-each 循环

public class Demo02 {
    public static void main(String[] args) {
        //输出数组元素的和
        int[] arrays = {1,2,3,4,5};
        int sum = 0;
        for (int each : arrays) {
            sum += each;
        }
        System.out.println("sum = "+ sum);
    }
}

数组作方法入参

public class Demo03 {
    public static void main(String[] args) {
        int[] arrarys = {1,2,3,4,5};
        printArray(arrarys);
    }
    //遍历数组元素
    public static void printArray(int[] arrays) {
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i]+" ");
        }
    }
}

数组作返回值

public class Demo04 {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5};
        printArray(reverse(arrays));
    }
    //反转数组
    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;
    }
    public static void printArray(int[] arrays) {
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i] + " ");
        }
    }
}

多维数组

多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一堆数组，其每一个元素都是一个一维数组。
二维数组
```
int[][] a = new int[2][5];
```
解析：以上二维数组 a 可以看成一个两行五列的数组。

遍历一个二维数组的值：

public class Demo05 {
    public static void main(String[] args) {
        //定义一个二维数组
        int[][] arrays = {{1,2},{3,4},{5,6}};
        //遍历二维数组的值
        for (int i = 0; i < arrays.length; i++) {
            for (int j = 0; j < arrays[i].length; j++) {
                System.out.print(arrays[i][j]+" ");
            }
            System.out.println();
        }
    }
}

Arrays 类

数组的工具类 java.util.Arrays
由于数组对象本身并没有什么方法可以供我们调用，但API中提供了一个工具类Arrays供我们使用，从而可以对数据对象进行一些基本的操作。
Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而不用使用对象来调用（注意：是不用而不是不能）。
Arrays类具有以下常用功能：
- 给数组赋值：通过 fill 方法。
- 对数组排序：通过 sort 方法，按升序。
- 比较数组：通过 equals 方法比较数组中元素是否相等。
- 查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。

import java.util.Arrays;

public class Demo06 {
    public static void main(String[] args) {
        //定义两个数组
        int[] a = {1,2,3,3,3,4,5,890,27,-6};
        int[] b = {1,2,3,4,5,6};
        //打印出数组a
        System.out.println(Arrays.toString(a));
        //将数组a的第2和第3个元素用0填充
        Arrays.fill(a, 2, 4, 0);
        System.out.println(Arrays.toString(a));
        //对数组a进行升序排序
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
        //判断数组a是否等于b
        if (Arrays.equals(a, b)){
            System.out.println("a = b");
        }else {
            System.out.println("a != b");
        }
        //查找数组a中的890
        System.out.println(Arrays.binarySearch(a, 890)); //排序后 890 的索引值为9
    }
}

稀疏数组
- 需求：编写五子棋游戏中，有存盘退出和续上盘的功能。
- 分析问题：可因为该二维数组的很多值是默认值0，因此记录了很多没有意义的数据。
- 解决：稀疏数组

稀疏数组介绍

当一个数组中大部分元素为0，或者为同一值的数组时，可以使用稀疏数组来保存该数组。
稀疏数组的处理方式是：
- 记录数组一共有几行几列，有多少个不同值
- 把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模。

如下图：左边是原始数组，右边是稀疏数组

我们来看下二维数组和稀疏数组之间的转换：

public class Demo08 {
    public static void main(String[] args) {
        //创建一个二维数组 11*11 0:没有棋子 1：黑棋 2：白棋
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;
        //输出原始数组
        System.out.println("输出原始数组：");
        for (int[] eachArray1 : array1) {
            for (int each : eachArray1) {
                System.out.print(each +"  ");
            }
            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++;
                }
            }
        }
        //创建一个稀疏数组的数组
        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");
        }
        //还原成二维数组
        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];
            }
        System.out.println("还原为二维数组结果：");
        for (int[] eachArray3 : array3) {
            for (int each : eachArray3) {
                System.out.print(each +"  ");
            }
            System.out.println();
        }
    }
}

posted @ 2021-03-26 14:36 都怪你阅读(63) 评论(0) 收藏举报

刷新页面返回顶部

都怪你

16、数组

数组

数组概述

数组声明创建

Java内存分析

三种初始化

数组的基本特点

数组边界

数组使用

普通的for循环

for-each 循环

数组作方法入参

数组作返回值

多维数组

Arrays 类

稀疏数组

稀疏数组介绍

公告