数组的相关知识

最新推荐文章于 2024-01-31 22:59:00 发布

久昔

最新推荐文章于 2024-01-31 22:59:00 发布

阅读量1.5k

点赞数 1

文章标签： java

本文链接：https://blog.csdn.net/weixin_927326/article/details/122850821

版权

数组

1、概念

1、数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。

2、数组既可以存储基本数据类型，也可以存储引用数据类型。

2、语句定义格式：

格式1：数据类型[] 数组名;

举例：int[] arr; 推荐第一种方式。

格式2：数据类型数组名[];

举例：int arr[] 定义一个存放int类型数据的数组。

为什么不推荐使用第二种方式？

从辨识度来看，第一种一眼就能识别是一个数组。

从使用长久来看，今后使用的趋势是第一种，第二种渐渐会被淘汰。

3、初始化

数组不初始化不能被使用，初始化就是给这个变量开辟一个内存空间，为将来的值提供存放的空间。

那么数组如何初始化呢？（两种）

1、动态初始化：

初始化时只指定数组长度，由系统为数组分配初始值。

动态初始化的语句格式：

存放元素的数据类型[] 数组名 = new 存放元素的数据类型[数组的长度];

举例：定义一个可以存放3个int类型数据的数组。

int [] bigdata15 = new int[3];

如何获取数组中的元素呢？

java在数组中提供了一个类似于下标的说法，我们可以通过下标获取到该下标位置上的元素，这个下标有一个专业的叫法：索引(index)，从左往右编号，从0开始。举例：现在数组的长度是3，索引从0开始，最大可以到2，也就是长度-1 。

获取数组元素的格式：数组名[想要获取元素的对应索引] System.out.println(arr[0]); //获取第一个元素 0 System.out.println(arr[1]); //获取第二个元素 0 System.out.println(arr[2]); //获取第三个元素 0

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dBMdNjyH-1644415579404)(C:\Users\s'tu\AppData\Roaming\Typora\typora-user-images\image-20220204163405539.png)]$

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Pll254Ue-1644415579405)(C:\Users\s'tu\AppData\Roaming\Typora\typora-user-images\image-20220204163414036.png)]$

如何给数组中的元素进行赋值呢？通过数组中的索引给元素进行赋值

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wbFPjPY7-1644415579406)(C:\Users\s'tu\AppData\Roaming\Typora\typora-user-images\image-20220204163449773.png)]$

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XfUAn9cU-1644415579407)(C:\Users\s'tu\AppData\Roaming\Typora\typora-user-images\image-20220204163457969.png)]$

2、静态初始化：

初始化时指定每个数组元素的初始值，由系统JVM决定数组长度。(JVM根据我们给的元素个数自动推断长度)

静态初始化的语句格式：

数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3,元素4…};

举例：int[] arr = new int[]{11,22,33,44,55};

表示的是定义一个存放5个int类型元素的数组，元素分别是11,22,33,44,55

简化写法：

数据类型[] 数组名 = {元素1,元素2,元素3,元素4…};

举例：int[] arr = {100,200,300,400};

表示的是定义一个存放4个int类型元素的数组，元素分别是100,200,300,400

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pRTB79Qm-1644415579407)(C:\Users\s'tu\AppData\Roaming\Typora\typora-user-images\image-20220204163850018.png)]$

**注意：**数组中常见的错误：

1、ArrayIndexOutOfBoundsException: 5

数组索引越界异常访问了不该访问的索引。

2、NullPointerException 空指针异常

	 3、注意动态初始化不能与静态初始化混合使用！

4、举例

1、数组遍历：

java中数组提供了一个属性供我们使用，可以获取数组的长度

这个属性叫做：length

使用格式：数组名.length

当长度可以确定后，for循环的索引范围就能确定了：length-1

public class ArrayBianLi {
    public static void main(String[] args) {
        int [] arr={1,2,3,4,5};
        System.out.print(arr[0]);
        System.out.print(arr[1]);
        System.out.print(arr[2]);
        System.out.print(arr[3]);
        System.out.print(arr[4]);

        System.out.println();
        System.out.println("=======for循环改进=======");

        for(int i=0;i<=arr.length-1;i++){
            if(i==0){
                System.out.print("["+arr[i]+",");
            }else if(i== arr.length-1){
                System.out.print(arr[i]+"]");
            }else {
                System.out.print(arr[i]+",");
            }
        }
        
        
        System.out.println();
        System.out.println("========定义方法======");
        printArray(arr);
    }
       /*
        定义遍历数组的方法
        返回值类型 void
        参数类型    int[] arr
         */
    public static void printArray(int [] arr){
        for(int i=0;i<=arr.length-1;i++){
            if(i==0){
                System.out.print("["+arr[i]+",");
            }else if(i== arr.length-1){
                System.out.print(arr[i]+"]");
            }else {
                System.out.print(arr[i]+",");
            }
        }
    }
}

2、数组获取最值(获取数组中的最大值最小值)

public class ArrayDemo8 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        //思路：任意取一个值，假设它就是最大值
        //然后拿着这个值与其余的值做比较，如果说遇到了比它还大的值，将该值作为临时最大值，当遍历完之后，获取到真正的最大值
        //一般情况下，取第一个元素为最大值
        int max = arr[0];

        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }

        System.out.println("数组中最大值为：" + max);

        System.out.println("======用方法改进=====");
        int maxNumber = getMaxNumber(arr); //0x001
        System.out.println("数组中最大值为：" + maxNumber);

    }
    /**
     *      定义一个获取数组最大值的方法
     *          返回值类型：int
     *          参数列表：int[] arr
     */
    public static int getMaxNumber(int[] arr1){ 
        int max = arr1[0];

        for (int i = 1; i < arr1.length; i++) {
            if (arr1[i] > max) {
                max = arr1[i];
            }
        }
        return max;
    }
}

3、逆序 (就是把元素对调)

public class ArrayDemo9 {
    public static void main(String[] args) {
        int[] arr = {43,31,123,1,21};
        //{43,31,123,1,21} ==> {21,1,123,32,43}
        System.out.print("数组逆序之前：");
        printArray(arr);

        //将0索引位置的元素与length-1位置上的元素进行交换
        //将1索引位置的元素与length-1-1位置上的元素进行交换
        //直到length/2
        int temp = arr[0];
        arr[0] = arr[arr.length-1];
        arr[arr.length-1] = temp;

        int temp2 = arr[1];
        arr[1] = arr[arr.length-1-1];
        arr[arr.length-1-1] = temp2;

        //调用方法遍历数组
        System.out.print("\r\n数组逆序之后：");
        printArray(arr);

        System.out.println("\r\n==================用for循环改进实现数组逆序1：==================");
        int[] niXuArray1 = niXu(arr);
        printArray(niXuArray1);

//        System.out.println("\r\n==================用for循环改进实现数组逆序2(创建新的数组)：==================");
//        int[] niXuArray2 = niXu2(arr);
//        printArray(niXuArray2);

        System.out.println("\r\n==================用for循环改进实现数组逆序3(定义指针)：==================");
        int[] niXuArray3 = niXu3(arr);
        printArray(niXuArray3);
    }
    /**
     *  定义方法实现数组的逆序(方法3)指针
     *      返回值类型：int[]
     *      参数列表：int[] array
     */
    public static int[] niXu3(int[] array){
        for(int start=0,end=array.length-1;start<=end;start++,end--){
            int temp = array[start];
            array[start] = array[end];
            array[end] = temp;
        }
        return array;
    }
    /**
     *      定义方法实现数组逆序(方法2)
     *          返回值类型：int[]
     *          参数列表：int[] array
     *
     *          这种方式不推荐：
     *              1、由于创建了新的数组，开辟了新的堆内存空间，这样会造成内存资源浪费
     *              2、题目本来的意思，在原数组上做逆序
     *
     */
    public static int[] niXu2(int[] array){
        int[] arr2 = new int[array.length];
        for(int i=array.length-1;i>=0;i--){
            arr2[arr2.length-1-i] = array[i];
        }
        return arr2;
    }
    /**
     *      实现数组逆序的方法(第一种方式实现)
     *          返回值类型：int[]
     *          参数列表：int[] array
     */
    public static int[] niXu(int[] array){
        for(int index=0;index<array.length/2;index++){
            int temp = array[index];
            array[index] = array[array.length-1-index];
            array[array.length-1-index] = temp;
        }
        return array;
    }
    /**
     *  定义遍历数组的方法
     *      返回值类型：void
     *      参数列表：int[] arr
     */
    public static void printArray(int[] arr){
        for(int i=0;i<arr.length;i++){
            if(i==0){
                System.out.print("["+arr[i]+",");
            }else if(i==arr.length-1){
                System.out.print(arr[i]+"]");
            }else {
                System.out.print(arr[i]+",");
            }
        }
    }
}

4、数组查表法(根据键盘录入索引,查找对应星期)

import java.util.Scanner;
public class ArrayDemo10 {
    public static void main(String[] args) {
        String[] week = {"星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期日"};

        Scanner sc = new Scanner(System.in);

        boolean flag = true;

        while (flag) {
            System.out.println("请输入数据（1-7）:");
            int number = sc.nextInt();
            if (number >= 1 & number <= 7) {
                System.out.println(week[number - 1]);
            } else if (number == 0) {
                flag = false;
            } else {
                System.out.println("输入的数据有误，请重新输入！");
            }
        }
    }
}

5、数组元素查找(查找指定元素第一次在数组中出现的索引)

举例：{12，32，12，43，53，32，100，12} 32在数组中第一次出现的索引为1

import java.util.Scanner;
public class ArrayDemo11 {
    public static void main(String[] args) {
        //定义一个数组并静态初始化
        int[] arr = {12,32,12,43,53,32,100,12};
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);

        System.out.println("请输入你要查找的元素：");
        int number = sc.nextInt();

        for(int i=0;i<arr.length;i++){
            if(arr[i]==number){
                System.out.println(number+"在数组中第一次出现的索引为"+i);
                //正确做法是查找到对应元素后，应该结束整个循环
                break;
            }
            if(i==arr.length-1 && arr[arr.length-1]!=number){
                System.out.println("您要查找的元素"+number+"不在数组中！");
            }
        }
    }
}

5、二维数组概述

其实二维数组其实就是一个元素为一维数组的数组。

语句定义格式：

数据类型[][] 变量名 = new 数据类型[m][n] (推荐这种写法)

m表示这个二维数组有多少个一维数组

n表示每一个一维数组的元素个数

举例：

int[][] arr = new int[3][2];

定义了一个二维数组arr

这个二维数组有3个一维数组，名称是arr[0],arr[1],arr[2]

每个一维数组有2个元素，可以通过arr [m][n]来获取

表示获取第m+1个一维数组的第n+1个元素

注意：还有可能看到以下几个写法，它们也是正确的：

1、int[] arr[] = new int[3][2];

2、int arr[][] = new int[3][2];

public class Array2Demo1 {
    public static void main(String[] args) {
        //定义一个二维数组，使用格式一做初始化
        int[][] arr = new int[3][2];

        System.out.println(arr);  //  [[I@4554617c
        System.out.println(arr[0]); // [I@74a14482
        System.out.println(arr[1]); // [I@1540e19d
        System.out.println(arr[2]); // [I@677327b6

        //想获取第一个一维数组中的第一个元素怎么办呢？
        //首先，得获取第一个一维数组
//        int[] array1 = arr[0];
//        //然后通过索引获取第一个元素
//        System.out.println(array1[0]);
        System.out.println(arr[0][0]);
        System.out.println(arr[0][1]); //获取二维数组中第一个一维数组中的第二个元素
        //ArrayIndexOutOfBoundsException: 2
//        System.out.println(arr[0][2]); //获取二维数组中第一个一维数组中的第二个元素

        System.out.println(arr[1][0]);  //获取二维数组中第二个一维数组中的第一个元素
        System.out.println(arr[1][1]);  //获取二维数组中第二个一维数组中的第二个元素

        System.out.println(arr[2][0]);  //获取二维数组中第三个一维数组中的第一个元素
        System.out.println(arr[2][1]);  //获取二维数组中第三个一维数组中的第二个元素
    }
}

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bdiiADz0-1644415579408)(C:\Users\s'tu\AppData\Roaming\Typora\typora-user-images\image-20220204170312016.png)]$

第二种定义格式：

数据类型[][] 变量名 = new 数据类型[m][];

举例：int[][] arr = new int[3][];

public class Array2Demo2 {
    public static void main(String[] args) {
        //定义二维数组的第二种格式
        int[][] arr = new int[3][];
        System.out.println(arr);
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);

        //给二维数组种第一个元素赋值一个一维数组
        //赋值后的意义是：表示二维数组种第一个元素是一个长度为4的int类型的一维数组。
        arr[0] = new int[4];
        //赋值后的意义是：表示二维数组种第二个元素是一个长度为5的int类型的一维数组。
        arr[1] = new int[5];
        //赋值后的意义是：表示二维数组种第三个元素是一个长度为10的int类型的一维数组。
        arr[2] = new int[10];
        System.out.println(arr);  //二维数组的地址值
        System.out.println(arr[0]); //二维数组中第一个一维数组的地址值
        System.out.println(arr[1]); //二维数组中第二个一维数组的地址值
        System.out.println(arr[2]);//二维数组中第三个一维数组的地址值
    }
}

第三种格式：

数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}};

举例：int[][] arr = new int[][]{{1,2},{3,4,5},{1,2,34,5}};

简化版格式：

数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};

举例：int[][] arr = {{1,2},{3,4,5},{1,2,34,5}};

表示的是：二维数组arr中5}有三个一维数组，分别是{1,2}，{3,4,5}，{1,2,3,4,5}

public class Array2Demo3 {
    public static void main(String[] args) {
        //数组的第三种格式定义
        int[][] arr = {{1,2},{3,4,5},{1,2,34,5}};
        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[0][1]);

        //获取二维数组中第二个一维数组中所有元素
        System.out.println(arr[1][0]);
        System.out.println(arr[1][1]);
        System.out.println(arr[1][2]);

        //获取二维数组中第三个一维数组中所有元素
        System.out.println(arr[2][0]);
        System.out.println(arr[2][1]);
        System.out.println(arr[2][2]);
        System.out.println(arr[2][3]);
//        System.out.println(arr[2][4]);
    }
}

二维数组遍历

/*
        数加科技
            十三期
                小王,小李
            十四期
                小明,小刘,小张
            十五期
                小虎,小宇,小旺,小凯
            十六期
                小火,小杨,小爱,小周
 */
public class Array2Demo4 {
    public static void main(String[] args) {
        //定义一个二维数组表示是一个数加科技
        String[][] shujia = {{"小王", "小李"}, {"小明", "小刘", "小张"}, {"小虎", "小宇", "小旺", "小凯"}, {"小火", "小杨", "小爱", "小周"}};
            //外层循环遍历到的是每一个一维数组
            //要想获取每个一维数组中的元素，再进行一次for循环遍历
        for (int i = 0; i < shujia.length; i++) {
            System.out.println("第" + (i + 1) + "个数组：");
            for (int j = 0; j < shujia[i].length; j++) {
                if (j == shujia[i].length - 1) {
                    System.out.print(shujia[i][j] + "]");
                } else if (j == 0) {
                    System.out.print("[" + shujia[i][j] + ",");
                } else {
                    System.out.print(shujia[i][j] + ",");
                }
            }
            //每次内循环结束表示打印完一个一维数组，换行
            System.out.println();
        }
    }
}

公司年销售额求和

/*
        公司年销售额求和
            某公司按照季度和月份统计的数据如下：单位(万元)
            第一季度：22,66,44
            第二季度：77,33,88
            第三季度：25,45,65
            第四季度：11,66,99

 */
public class Array2XiaoShouE {
    public static void main(String[] args) {
        //定义一个二维数组表示是一个公司，每个季度相当于一个一维数组作为二维数组的元素传入
        int[][] arr = {{22, 66, 44}, {77, 33, 88}, {25, 45, 65}, {11, 66, 99}};

        int sum=0;
        for(int i=0;i<arr.length;i++){
            for(int j=0;j<arr[i].length;j++){
                sum=sum+arr[i][j];
            }
        }
        System.out.println("该年的销售额为："+sum);
    }
}

6、引用数据类型当参数传递时：

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dxmRcnqJ-1644415579409)(C:\Users\s'tu\AppData\Roaming\Typora\typora-user-images\image-20220204171010449.png)]$

7、基础数据类型当参数传递时：

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DDGK0axU-1644415579409)(C:\Users\s'tu\AppData\Roaming\Typora\typora-user-images\image-20220204171150838.png)]$