day7 7 Java数组中的一些注意事项

最新推荐文章于 2023-09-26 21:30:06 发布

雨夜※繁华

最新推荐文章于 2023-09-26 21:30:06 发布

阅读量236

点赞数 1

分类专栏： # java之路文章标签：算法 java 编程语言数据结构

本文链接：https://blog.csdn.net/qq_44861675/article/details/105406993

版权

java之路专栏收录该内容

50 篇文章 3 订阅

订阅专栏

文章目录

7、java数组里的注意事项

7、java数组里的注意事项

7.1 数组的简介

数组（array）是一种最简单的复合数据类型，它是有序数据的集合，数组中的每个元素具有相同的数据类型，可以用一个统一的数组名和不同的下标来确定数组中唯一的元素。根据数组的维度，可以将其分为一维数组、二维数组和多维数组等。

在计算机语言中数组是非常重要的集合类型，大部分计算机语言中数组具有如下三个基本特性：

一致性：数组只能保存相同数据类型元素，元素的数据类型可以是任何相同的数据类型。
有序性：数组中的元素是有序的，通过下标访问。
不可变性：数组一旦初始化，则长度（数组中元素的个数）不可变。

总的来说，数组具有以下特点：

数组可以是一维数组、二维数组或多维数组。
数值数组元素的默认值为 0，而引用元素的默认值为 null。
数组的索引从 0 开始，如果数组有 n 个元素，那么数组的索引是从 0 到（n-1）。
数组元素可以是任何类型，包括数组类型。
数组类型是从抽象基类 Array 派生的引用类型。

请注意，Java 数组的工作原理与C++不同

7.2 注意事项

7.2.1 java数组的定义及初始化形式

1.一维数组（3种）

1）先声明再分配空间再初始化

int []score;//声明
score = new int[2];//分配空间
score[0] = 1;//赋值
score[1] = 2;

声明的同时分配空间再初始化

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

以上两种其实可以说是同一种。

2）声明的同时分配空间、初始化

int []score = new int[]{1,2};//(方括号里面不能有数字)
//错误写法 int[]score = new int[2]{1,2};

3）声明的同时初始化

int []score = {1,2};

例子

package Arraydata;

public class Notice_Demo {
    public static void main(String[]args){
        int []score ;
        score = new int[2];
        score[0]=1;
        score[1]=2;
        System.out.println("形式1："+score[0]+" "+score[1]);

        int []score1 = new int[2];
        score1[0]=1;
        score1[1]=2;
        System.out.println("形式2："+score1[0]+" "+score1[1]);

        int []score2= new int[]{1,2};
        System.out.println("形式3："+score2[0]+" "+score2[1]);

        int []score3 = {1,2};
        System.out.println("形式4："+score3[0]+" "+score3[1]);
    }
}

在这里插入图片描述

2.二维数组(3种)

int[][] temp = new int[][]{值 1,值 2,值 3,…,值 n};    // 在定义时初始化
int[][] temp = new int[size1][size2];    // 给定空间，在赋值
int[][] temp = new int[size][];    // 数组第二维长度为空，可变化，进而得到不规则数组

3.多维数组（含不规则数组）

想要提高数组的维数，只要在声明数组时将索引与中括号再加一组即可，所以三维数组的声明为 int score[][][]，而四维数组为 int score[][][][]，以此类推。
通常也将二维数组看作是多维数组。

public static void main(String[] args) {
    String[][][] namelist = { { { "张阳", "李风", "陈飞" }, { "乐乐", "飞飞", "小曼" } },
            { { "Jack", "Kimi" }, { "Lucy", "Lily", "Rose" } }, { { "徐璐璐", "陈海" }, { "李丽丽", "陈海清" } } };
    for (int i = 0; i < namelist.length; i++) {
        for (int j = 0; j < namelist[i].length; j++) {
            for (int k = 0; k < namelist[i][j].length; k++) {
                System.out.println("namelist[" + i + "][" + j + "][" + k + "]=" + namelist[i][j][k]);
            }
        }
    }
}

建议使用的初始化形式是：

type [][][] temp = {值1，值2，值3};//注意这里的值1，值2等是更低一级维度的数组（长度是否相等区别为规则与不规则）。类似于python多维数组列表的形式

7.2.2 规则的数组与不规则的数组

规则的 4×3 二维数组有 12 个元素，而不规则数组就不一定了。如下代码静态初始化了一个不规则数组。

int intArray[][] = {{1,2}, {11}, {21,22,23}, {31,32,33}};

注意！！！

Java 实际上没有多维数组，只有一维数组。
多维数组被解释为是数组的数组，所以因此会衍生出一种不规则数组。

7.2.3 使用 for-each来简化遍历数组（样例迷宫小游戏）

package Arraydata;
import java.util.Scanner;
public class Array_demo {
    /**
     *  步骤分析:
     *             1.打印地图  ---- 二维数组的遍历
     *     初始坐标 array[1][1]
     *     结束坐标 array[1][9]
     *             2.如何让0走起来
     *     通过修改 横纵坐标 让'P'走起来
     *     如何碰到墙 '#' 不移动
     *     可以先把要走的位置元素 取出来判断一下 是不是墙
     *     是墙就不动 不是墙再进行移动
     *     3.循环输入(循环的停止条件 结束坐标位置 从' '变成'0')
     *       使用while循环比较方便
     */
    public static void main(String[] args) {
        // 有8个一维数组 每个一维数组中有10个元素
        char[][] array = {
                //y   0   1   2   3   4   5   6   7   8   9
                    {'#','#','#','#','#','#','#','#','#','#'},//0 ----- x
                    {'#','P',' ',' ',' ',' ','#','#',' ',' '},//1
                    {'#','#',' ','#','#','#','#','#',' ','#'},//2
                    {'#',' ',' ',' ',' ','#','#','#',' ','#'},//3
                    {'#',' ','#','#',' ','#',' ',' ',' ','#'},//4
                    {'#',' ','#','#',' ','#',' ','#','#','#'},//5
                    {'#',' ',' ',' ',' ',' ',' ','#','#','#'},//6
                    {'#','#','#','#','#','#','#','#','#','#'},//7
        };
        // 打印地图
        printMap(array);
        // 声明要用的变量 起始
        int x = 1;
        int y = 1;
        // 结束
        int ex = 1;
        int ey = 9;
        Scanner scanner = new Scanner(System.in);
        // 提示输入 w a s d
        while (array[ex][ey] != 'P') {
            System.out.println("请输入w a s d进行移动");
            // 接收输入的值
            String string = scanner.nextLine();
            // 判断往哪里移动
            switch (string) {
                case "w": case "W":
                    if (array[x - 1][y] != '#') {
                        // 把原来的改空格
                        array[x][y] = ' ';
                        // 向左移动
                        x = x - 1;
                        array[x][y] = 'P';
                    }
                    break;
                case "a": case"A":
                    if (array[x][y - 1] != '#') {
                        // 把原来的改空格
                        array[x][y] = ' ';
                        // 向左移动
                        y = y  - 1;
                        array[x][y] = 'P';
                    }
                    break;
                case "s": case"S":
                    if (array[x + 1][y] != '#') {
                        // 把原来的改空格
                        array[x][y] = ' ';
                        // 向左移动
                        x = x + 1;
                        array[x][y] = 'P';
                    }
                    break;
                case "d": case"D":
                    // 判断是不是墙
                    if (array[x][y + 1] != '#') {
                        // 把原来的改空格
                        array[x][y] = ' ';
                        // 向左移动
                        y = y  + 1;
                        array[x][y] = 'P';
                    }
                    break;
                default:
                    break;
            }
            // 修改完毕后 再打印一遍地图
            printMap(array);
        }
        System.out.println("恭喜通关!");
    }

    // 打印地图的方法
    public static void printMap(char[][] array) {
        System.out.print(" ");
        for(int i=0;i<10;i++){
            System.out.print(i+"");
        }
        System.out.println();
        int j=0;
        for (char[] chars : array) {
            System.out.print(j+"");
            for (char aChar : chars) {
                System.out.print(aChar);
            }
            System.out.println();
            j++;
        }
    }
}

在这里插入图片描述
我们在打印地图的函数里面使用了for-each循环遍历数组。

7.3 Array工具类

Arrays 类是一个工具类，其中包含了数组操作的很多方法。这个 Arrays 类里均为 static 修饰的方法（static 修饰的方法可以直接通过类名调用），可以直接通过 Arrays.xxx(xxx) 的形式调用方法。

1）int binarySearch(type[] a, type key)

使用二分法查询 key 元素值在 a 数组中出现的索引，如果 a 数组不包含 key 元素值，则返回负数。调用该方法时要求数组中元素己经按升序排列，这样才能得到正确结果。

2）int binarySearch(type[] a, int fromIndex, int toIndex, type key)

这个方法与前一个方法类似，但它只搜索 a 数组中 fromIndex 到 toIndex 索引的元素。调用该方法时要求数组中元素己经按升序排列，这样才能得到正确结果。

3）type[] copyOf(type[] original, int length)

这个方法将会把 original 数组复制成一个新数组，其中 length 是新数组的长度。如果 length 小于 original 数组的长度，则新数组就是原数组的前面 length 个元素，如果 length 大于 original 数组的长度，则新数组的前面元索就是原数组的所有元素，后面补充 0（数值类型）、false（布尔类型）或者 null（引用类型）。

4）type[] copyOfRange(type[] original, int from, int to)

这个方法与前面方法相似，但这个方法只复制 original 数组的 from 索引到 to 索引的元素。

5）boolean equals(type[] a, type[] a2)

如果 a 数组和 a2 数组的长度相等，而且 a 数组和 a2 数组的数组元素也一一相同，该方法将返回 true。

6）void fill(type[] a, type val)

该方法将会把 a 数组的所有元素都赋值为 val。

7）void fill(type[] a, int fromIndex, int toIndex, type val)

该方法与前一个方法的作用相同，区别只是该方法仅仅将 a 数组的 fromIndex 到 toIndex 索引的数组元素赋值为 val。

8）void sort(type[] a)

该方法对 a 数组的数组元素进行排序。

9）void sort(type[] a, int fromIndex, int toIndex)

该方法与前一个方法相似，区别是该方法仅仅对 fromIndex 到 toIndex 索引的元素进行排序。

10）String toString(type[] a)

该方法将一个数组转换成一个字符串。该方法按顺序把多个数组元素连缀在一起，多个数组元素使用英文逗号,和空格隔开。

下面程序示范了 Arrays 类的用法。

public class ArraysTest {
    public static void main(String[] args) {
        // 定义一个a数组
        int[] a = new int[] { 3, 4, 5, 6 };
        // 定义一个a2数组
        int[] a2 = new int[] { 3, 4, 5, 6 };
        // a数组和a2数组的长度相等，毎个元素依次相等，将输出true
        System.out.println("a数组和a2数组是否相等：" + Arrays.equals(a, a2));
        // 通过复制a数组，生成一个新的b数组
        int[] b = Arrays.copyOf(a, 6);
        System.out.println("a数组和b数组是否相等：" + Arrays.equals(a, b));
        // 输出b数组的元素，将输出[3, 4, 5, 6, 0, 0]
        System.out.println("b 数组的元素为：" + Arrays.toString(b));
        // 将b数组的第3个元素（包括）到第5个元素（不包括）賦值为1
        Arrays.fill(b, 2, 4, 1);
        // 输出b数组的元素，将输出[3, 4, 1, 1, 0, 0]
        System.out.println("b 数组的元素为：" + Arrays.toString(b));
        // 对b数组进行排序
        Arrays.sort(b);
        // 输出b数组的元素.将输出[0,0,1,1,3,4]
        System.out.println("b数组的元素为：" + Arrays.toString(b));
    }
}

Arrays 类处于 java.util 包下，为了在程序中使用 Arrays 类，必须在程序中导入 java.util.Arrays 类。

注意在 System 类里的static void arraycopy(Object src, int srePos, Object dest, int dcstPos, int length)方法，该方法可以将 src 数组里的元素值赋给 dest 数组的元素，其中 srcPos 指定从 src 数组的第几个元素开始赋值，length 参数指定将 src 数组的多少个元素值赋给 dest 数组的元素。

Java 8 增强了 Arrays 类的功能，为 Arrays 类增加了一些工具方法，这些工具方法可以充分利用多 CPU 并行的能力来提高设值、排序的性能。下面是 Java 8 为 Arrays 类增加的工具方法。

提示：由于计算机硬件的飞速发展，目前几乎所有家用 PC 都是 4 核、8 核的 CPU，而服务器的 CPU 则具有更好的性能，因此 Java 8 与时俱进地增加了并发支持，并发支持可以充分利用硬件设备来提高程序的运行性能。

1）oid parallelPrefix(xxx[] array, XxxBinaryOperator op)

该方法使用 op 参数指定的计算公式计算得到的结果作为新的元素。op 计算公式包括 left、right 两个形参，其中 left 代表数组中前一个索引处的元素，right 代表数组中当前索引处的元素，当计算第一个新数组元素时，left 的值默认为 1。

2）void parallelPrefix(xxx[] array, int fromIndex, int toIndex, XxxBinaryOperator op)

该方法与上一个方法相似，区别是该方法仅重新计算 fromIndex 到 toIndex 索引的元素。

3）void setAll(xxx[] array, IntToXxxFunction generator)

该方法使用指定的生成器（generator）为所有数组元素设置值，该生成器控制数组元素的值的生成算法。

4）void parallelSetAll(xxx[] array, IntToXxxFunction generator)

该方法的功能与上一个方法相同，只是该方法增加了并行能力，可以利用多 CPU 并行来提高性能。

5）void parallelSort(xxx[] a)

该方法的功能与 Arrays 类以前就有的 sort() 方法相似，只是该方法增加了并行能力，可以利用多 CPU 并行来提高性能。

6）void parallelSort(xxx[] a，int fromIndex, int toIndex)

该方法与上一个方法相似，区別是该方法仅对 fromIndex 到 toIndex 索引的元素进行排序。

7）Spliterator.OfXxx spliterator(xxx[] array)

将该数组的所有元素转换成对应的 Spliterator 对象。

8）Spliterator.OfXxx spliterator(xxx[] array, int startInclusive, int endExclusive)

该方法与上一个方法相似，区别是该方法仅转换 startInclusive 到 endExclusive 索引的元素。

9）XxxStream stream(xxx[] array)

该方法将数组转换为 Stream，Stream 是 Java 8 新增的流式编程的 API。

10）XxxStream stream(xxx[] array, int startInclusive, int endExclusive)

该方法与上一个方法相似，区别是该方法仅将 fromIndex 到 toIndex 索引的元索转换为 Stream。

上面方法列表中，所有以 parallel 开头的方法都表示该方法可利用 CPU 并行的能力来提高性能。上面方法中的 xxx 代表不同的数据类型，比如处理 int[] 型数组时应将 xxx 换成 int，处理 long[] 型数组时应将 XXX 换成 long。

下面程序示范了 Java 8 为 Arrays 类新增的方法。

public class ArraysTest2 {
    public static void main(String[] args) {
        int[] arr1 = new int[] { 3, 4, 25, 16, 30, 18 };
        // 对数组arr1进行并发排序
        Arrays.parallelSort(arr1);
        System.out.println(Arrays.toString(arr1));
        int[] arr2 = new int[] { 13, -4, 25, 16, 30, 18 };
        Arrays.parallelPrefix(arr2, new IntBinaryOperator() {
            // left 代表数组中前一个索引处的元素，计算第一个元素时，left为1
            // right代表数组中当前索引处的元素
            public int applyAsInt(int left, int right) {
                return left * right;
            }
        });
        System.out.println(Arrays.toString(arr2));
        int[] arr3 = new int[5];
        Arrays.parallelSetAll(arr3, new IntUnaryOperator() {
            // operand代表正在计算的元素索引
            public int applyAsInt(int operand) {
                return operand * 5;
            }
        });
        System.out.println(Arrays.toString(arr3));
    }
}

上面程序中第一行粗体字代码调用了 parallelSort() 方法对数组执行排序，该方法的功能与传统 sort() 方法大致相似，只是在多 CPU 机器上会有更好的性能。

第二段粗体字代码使用的计算公式为 left * right，其中 left 代表数组中当前一个索引处的元素，right 代表数组中当前索引处的元素。程序使用的数组为：
{3, -4 , 25, 16, 30, 18)

计算新的数组元素的方式为：
{13=3, 3-4—12, -1225=-300, -30016=—48000, -4800030=—144000, -14400018=-2592000}

因此将会得到如下新的数组元素：
{3, -12, -300, -4800, -144000, -2592000)

第三段粗体字代码使用 operand * 5 公式来设置数组元素，该公式中 operand 代表正在计算的数组元素的索引。因此第三段粗体字代码计算得到的数组为：
{0, 5, 10, 15, 20}

雨夜※繁华

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
day7 7 Java数组中的一些注意事项

文章目录7、java数组里的注意事项7.1 数组的简介7.2 注意事项7.2.1 java数组的定义及初始化形式1.一维数组（3种）2.二维数组(3种)3.多维数组（含不规则数组）7.2.2 规则的数组与不规则的数组7.2.3 使用 for-each来简化遍历数组（样例迷宫小游戏）7.3 Array工具类7、java数组里的注意事项7.1 数组的简介数组（array）是一种最简单的复合数据...
复制链接

扫一扫