Java中的数组

最新推荐文章于 2024-04-30 17:28:01 发布
最新推荐文章于 2024-04-30 17:28:01 发布
阅读量1k 收藏 2
点赞数 1
文章标签： java python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_59701086/article/details/131548776
版权

数组

1.数组基本概念

​ 数组就是存储数据长度固定的容器，存储多个数据的数据类型要一致。

数组的定义格式：

第一种格式：
​ 数据类型[] 数组名
​ 示例：

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

第二种格式：
​ 数据类型 数组名[]
​ 示例：

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

2.数组的动态初始化

2.1数组的定义：

数组动态初始化就是只给定数组的长度，由系统给出默认初始化值

2.2动态初始化格式：

数据类型[] 数组名 = new 数据类型[数组长度];

int[] arr = new int[3];
动态初始化格式详解
- 等号左边：

  -  int:数组的数据类型

  -  []:代表这是一个数组

  -  arr:代表数组的名称

- 等号右边：

  -   new:为数组开辟内存空间
  -   int:数组的数据类型
  -   []:代表这是一个数组
  -   3:代表数组的长度

package com.itheima.array;

public class Demo2Array {
    /*
        数组的动态初始化:
                        在初始化的时候, 需要手动指定数组的长度, 系统会为数组容器分配初始值.

        动态初始化格式:
                        数据类型[] 数组名 = new 数据类型[数组的长度];

        注意:
                        打印数组变量的时候, 会打印出数组的内存地址

        [I@10f87f48 :

                        @ : 分隔符
                        [ : 当前的空间是一个数组类型
                        I : 当前数组容器中所存储的数据类型（I:表示是一个int类型的数组，B:表示是一个byte类型数组）
                        10f87f48 : 十六进制内存地址

                                0 1 2 3 4 5 6 7 8 9 a b c d e f
     */
    public static void main(String[] args) {
        // 数据类型[] 数组名 = new 数据类型[数组的长度];
        // 通过new关键字创建了一个int类型的数组容器, 该容器可以存储5个int类型的整数, 该容器被arr数组变量所记录
        int[] arr = new int[5];
        // [I@10f87f48
        System.out.println(arr);

        byte[] bArr = new byte[3];
        // [B@b4c966a
        System.out.println(bArr);

    }
}

3. 数组元素访问

3.1 什么是索引

​ 每一个存储到数组的元素，都会自动的拥有一个编号，从0开始。

​ 这个自动编号称为数组索引(index)，可以通过数组的索引访问到数组中的元素。

3.2访问数组元素格式

数组名[索引];

示例代码：

package com.itheima.array;

public class Demo3ArrayIndex {
    /*
        数组动态初始化:
                初始化的时候, 手动指定数组长度, 系统会为数组容器分配初始值.

        数组的元素访问格式:
                数组名[索引]

                索引: 数组中数据的编号方式, 编号从0开始
                作用: 访问数组容器中的空间位置

        注意:
                数组在创建完毕后, 即使没有赋值, 也可以取出, 但取出的元素都是默认初始化值.

     */
    public static void main(String[] args) {
        int[] arr = new int[3];         // 0 1 2
        System.out.println(arr);        // 数组的内存地址  [I@10f87f48

        // 数组名[索引]  访问数组容器中的空间位置
        System.out.println(arr[0]);     // 0  系统自动分配的默认初始化值
        System.out.println(arr[1]);
        System.out.println(arr[2]);

        System.out.println("--------------");

        // 数组名[索引]
        arr[0] = 11;
        arr[1] = 22;
        arr[2] = 33;

        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
    }
}

4.内存分配

4.1 内存概述

​ 内存是计算机中的重要原件，临时存储区域，作用是运行程序。

​ 我们编写的程序是存放在硬盘中的，在硬盘中的程序是不会运行的。

​ 必须放进内存中才能运行，运行完毕后会清空内存。

4.2 java中的内存分配

​Java虚拟机要运行程序，必须要对内存进行空间的分配和管理。
目前我们只需要记住两个内存，分别是：栈内存和堆内存

区域名称作用
寄存器给CPU使用，与开发无关。
本地方法栈JVM在使用操作系统功能的时候使用，和开发无关。
方法区存储可以运行的class文件。
堆内存存储对象或者数组，new来创建的，都存储在堆内存。
方法栈方法运行时使用的内存，比如main方法运行，进入方法栈中执行。
int[] arr = new int[3];//输出数组名及元素
System.out.println(arr);
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
//数组在初始化时，会为存储空间添加默认值
整数：默认值0
浮点数：默认值0.0
布尔值：默认值false
字符：默认值是空字符
引用数据类型：默认值是null

4.3Java内存分配-一个数组内存图

在这里插入图片描述

4.4Java内存分配-两个数组内存图

在这里插入图片描述

4.5Java内存分配-多个数组指向相同内存图

在这里插入图片描述

5.数组的静态初始化

静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度

格式：数据类型 [ ] 变量名 =  new  数据类型[ ] { 数据1 , 数据2 , 数据3 , ……} ;
范例：         int [ ]       arr =  new           int[ ] { 1 , 2 , 3 } ;

简化格式：数据类型 [ ] 变量名 = { 数据1 , 数据2 , 数据3 , ……} ;
范例：                int [ ]       arr = { 1 , 2 , 3 } ;

示例代码：

package com.itheima.array2;

public class Demo1Array {
    /*
        数组静态初始化 : 初始化时指定每个数组元素的初始值，由系统决定数组长度

        完整格式:
                    数据类型[] 数组名 = 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]);

    }
}

6.数组操作的两个常见问题

6.1 索引越界异常

索引越界：访问了数组中不存在的索引对应的元素，造成索引越界问题

出现原因

public class ArrayDemo {
    public static void main(String[] args) {
        int[] arr = new int[3];
        System.out.println(arr[3]);
    }
}

  • 数组长度为3，索引范围是0~2，但是我们却访问了一个3的索引。

    程序运行后，将会抛出ArrayIndexOutOfBoundsException
    数组越界异常。在开发中，数组的越界异常是不能出现的，一旦出现了，就必须要修改我们编写的代码。

    • 解决方案

      将错误的索引修改为正确的索引范围即可！

6.2 空指针异常

空指针异常：访问的数组已经不再指向堆内存的数据，造成空指针异常

出现原因：

public class ArrayDemo { public static void main(String[] args) {
        int[] arr = new int[3];

        //把null赋值给数组
        arr = null;
        System.out.println(arr[0]);
    }
}

null：空值，引用数据类型的默认值，表示不指向任何有效对象

  • arr = null 这行代码，意味着变量arr将不会在保存数组的内存地址，也就不允许再操作数组了，因此运行的时候会抛出 NullPointerException 空指针异常。

  • 在开发中，空指针异常是不能出现的，一旦出现了，就必须要修改我们编写的代码。

  • 解决方案

    给数组一个真正的堆内存空间引用即可！

7.数组遍历

数组遍历：就是将数组中的每个元素分别获取出来，就是遍历。遍历也是数组操作中的基石。

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

以上代码是可以将数组中每个元素全部遍历出来，但是如果数组元素非常多，这种写法肯定不行，因此我们需要改造成循环的写法。
获取数组元素数量：

格式：数组名.length
范例：arr.length

数组的索引是 0 到 lenght-1 ，可以作为循环的条件出现。

public class ArrayTest01 {
    public static void main(String[] args) {
        //定义数组
        int[] arr = {11, 22, 33, 44, 55};

        //使用通用的遍历格式
        for(int x=0; x<arr.length; x++) {
            System.out.println(arr[x]);
        }
    }
}

8.数组获取最大值

  • 最大值获取：从数组的所有元素中找出最大值。

  • 实现思路：

    • 定义变量，保存数组0索引上的元素
    • 遍历数组，获取出数组中的每个元素
    • 将遍历到的元素和保存数组0索引上值的变量进行比较
    • 如果数组元素的值大于了变量的值，变量记录住新的值
    • 数组循环遍历结束，变量保存的就是数组中的最大值

  • 代码实现：

package com.itheima.test;

import java.util.Scanner;

public class Test2Array {
    /*
        需求: 从数组中查找最大值

                int[] arr = {12,45,98,73,60};

        实现步骤:
                1. 假设数组中的第一个元素为最大值
                2. 遍历数组, 获取每一个元素, 准备进行比较
                3. 如果比较的过程中, 出现了比max更大的, 让max记录更大的值
                4. 循环结束后, 打印最大值.
     */
    public static void main(String[] args) {
        int[] arr = {12,45,98,73,60};
        // 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);
    }
}

9.数组元素求和

  • 需求：键盘录入5个整数，存储到数组中，并对数组求和

  • 思路：
    1.创建键盘录入对象，准备键盘录入
    2.定义一个求和变量，准备记录累加后的结果
    3.动态初始化一个长度为5的int数组，准备存储键盘录入的数值
    4.将键盘录入的数值存储到数组中
    5.遍历数组，取出每一个元素，并求和
    6.输出总和

  • 代码实现：

package com.itheima.test;

import java.util.Scanner;

public class Test3Array {
    /*
        需求：键盘录入5个整数，存储到数组中，并对数组求和

        思路：
            1.创建键盘录入对象，准备键盘录入
            2.定义一个求和变量，准备记录累加后的结果
            3.动态初始化一个长度为5的int数组，准备存储键盘录入的数值
            4.将键盘录入的数值存储到数组中
            5.遍历数组，取出每一个元素，并求和
            6.输出总和
     */
    public static void main(String[] args) {
        // 1.创建键盘录入对象，准备键盘录入
        Scanner sc = new Scanner(System.in);
        // 2.定义一个求和变量，准备记录累加后的结果
        int sum = 0;
        // 3.动态初始化一个长度为5的int数组，准备存储键盘录入的数值
        int[] arr = new int[5];
        // 4.将键盘录入的数值存储到数组中
        for(int i = 0; i < arr.length; i++){
            System.out.println("请输入第" + (i+1) + "个整数:");
            //arr[i] = 10;
            arr[i] = sc.nextInt();
        }

        // 5.遍历数组，取出每一个元素，并求和
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }

        // 6.输出总和
        System.out.println("sum:" + sum);

    }
}

10.数组基本查找【应用】

  • 需求：
    已知一个数组 arr = {19, 28, 37, 46, 50}; 键盘录入一个数据，查找该数据在数组中的索引，并在控
    制台输出找到的索引值。

  • 思路：
    1.定义一个数组，用静态初始化完成数组元素的初始化
    2.键盘录入要查找的数据，用一个变量接收
    3.定义一个索引变量，初始值为-1
    4.遍历数组，获取到数组中的每一个元素
    5.拿键盘录入的数据和数组中的每一个元素进行比较，如果值相同，就把该值对应的索引赋值给索引变量，并结束循环
    6.输出索引变量

  • 代码实现：

public static void main(String[] args) {
        // 1.定义一个数组，用静态初始化完成数组元素的初始化
        int[] arr = {19, 28, 37, 46, 50};
        // 2.键盘录入要查找的数据，用一个变量接收
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入您要查找的元素:");
        int num = sc.nextInt();
        // 3.定义一个索引变量，初始值为-1
        // 假设要查找的数据, 在数组中就是不存在的
        int index = -1;
        // 4.遍历数组，获取到数组中的每一个元素
        for (int i = 0; i < arr.length; i++) {
            // 5.拿键盘录入的数据和数组中的每一个元素进行比较，如果值相同，就把该值对应的索引赋值给索引变量，并结束循环
            if(num == arr[i]){
                // 如果值相同，就把该值对应的索引赋值给索引变量，并结束循环
                index = i;
                break;
            }
        }
        //  6.输出索引变量
        System.out.println(index);
    }
}

11.评委打分【应用】

  • 需求：在编程竞赛中，有6个评委为参赛的选手打分，分数为0-100的整数分。
    选手的最后得分为：去掉一个最高分和一个最低分后 的4个评委平均值 (不考虑小数部分)。

  • 思路：
    1.定义一个数组，用动态初始化完成数组元素的初始化，长度为6
    2.键盘录入评委分数
    3.由于是6个评委打分，所以，接收评委分数的操作，用循环
    4.求出数组最大值
    5.求出数组最小值
    6.求出数组总和
    7.按照计算规则进行计算得到平均分
    8.输出平均分

  • 代码实现：

  public static void main(String[] args) {
        // 1.定义一个数组，用动态初始化完成数组元素的初始化，长度为6
        int[] arr = new int[6];
        // 2.键盘录入评委分数
        Scanner sc = new Scanner(System.in);
        //  3.由于是6个评委打分，所以，接收评委分数的操作，用循环
        for (int i = 0; i < arr.length; i++) {
            System.out.println("请输入第" + (i+1) + "个评委的打分:");
            int score = sc.nextInt();
            if(score >= 0 && score <= 100){
                // 合法的分值
                arr[i] = score;
            }else{
                // 非法的分值
                System.out.println("您的打分输入有误, 请检查是否是0-100之间的");
                i--;
            }
        }

        // 4.求出数组最大值
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if(max < arr[i]){
                max = arr[i];
            }
        }

        // 5.求出数组最小值
        int min = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if(min > arr[i]){
                min = arr[i];
            }
        }

        // 6.求出数组总和
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }

        // 7.按照计算规则进行计算得到平均分
        int avg = (sum - max - min ) / 4;

        // 8.输出平均分
        System.out.println(avg);
    }
}
玄月不圆
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Java中数组与集合的相互转换实现解析
08-25
主要介绍了Java中数组与集合的相互转换实现解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
【笔记】Java的数组、数组的三种定义格式、数组中元素的访问方式、数组的遍历
qq_51843109的博客
03-06 459
文章目录一、数组的概述二、数组的三种定义格式三、数组中元素的访问方式四、数组的遍历 一、数组的概述 二、数组的三种定义格式 三、数组中元素的访问方式 四、数组的遍历
Java基础——数组
D_ar_ker的博客
02-18 1163
Java基础中数组的学习，包含数组的定义及使用还有数组的存储结构
Java数组详解
weixin_51980361的博客
08-05 3947
学习笔记 — 数组和二维数组用法详解，包括声明创建、初始化、数组遍历以及内存图过程等
代码示例：Java中定义数组的三种方式
传智播客的专栏
04-23 6339
在Java中，数组的定义有三种方式，其基本语法格式如下：数组类型[] 数组名 = new 数组类型[数组长度]; 数组类型[] 数组名 = new 数组类型[]{数组元素0,数组元素...
Java 数组
zqm_1994的博客
05-17 149
数据类型 [][]数组名称 = new 数据类型[][]{{数值1，数值2},{数值1，数值2},.....} -----------二维。数据类型 数组名称[][] = new 数据类型[][]{{数值1，数值2},{数值1，数值2},.....} -----------二维。数据类型 数组名称[][] = {{数值1，数值2},{数值1，数值2},.....} -----------二维。数据类型 []数组名称={数据值1,数据值2,...数据值n} --------一维。
java数组定义格式，数组初始化，数组元素访问，内存分配，数组操作的两个常见问题，数组常见操作
2201_75956506的博客
07-25 330
2.堆内存：存储new出来的内容（实体，对象）数组在初始化时，会为存储空间添加默认值。作用：索引用于访问数组中的数据使用，数组名[索引]等同于变量名，是一种特殊的变量名。格式：数组类型[]变量名=new 数据类型[]{数据1，数据2，数据3...}；②静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。简化格式：数据类型[]变量名={数据1，数据2，数据3....}；初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。格式：数据类型[]变量名=new 数据类型[数组长度]；
java中数组的定义及使用方法(推荐)
09-01
下面小编就为大家带来一篇java中数组的定义及使用方法(推荐)。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
java中数组的应用及方法
09-05
本篇文章介绍了，java中数组的应用及方法。需要的朋友参考下
Java中数组的定义与使用
09-05
Java中数组的定义与使用
java数组结构图
11-15
对数组的总结和分析，通过这个结构记住它，在开发的过程中使用
Java 数组定义格式-数组动态初始化-数组元素的访问-数组静态初始化-数组的遍历-数组获取最大值
weixin_49345320的博客
03-17 2098
数组定义格式： 1.数组概述 在一个班级中，有非常多学生需要存储每位学生的考试成绩. 比如 a=98; b=97; c=96; d=88; …… 1)数组概述:一次性声明大量的用于存储数据的变量; 这些要存储的数据通常都是相同类型数据。例如:全班同学的考试成绩。 2)数组:是一种用于存储多个相同类型数据的存储模型 数组定义格式 范例1:推荐使用 定义格式1:数据类型[变量名int[] arr ; 含义:定义了一个int类型的数组，数组名是arr; 范例2: 数据类型变量名[]int arr []; /含义:
Java中三种数组的定义格式
学Javaの光
01-27 674
//需求：定义一个长度为三的数组 //格式一：虽然数组定义好了，但是具体存储哪三个数字不确定 int[] arr1 = new int[3]; //格式二:具体存储的数字是1，2，3 int[] arr2 = new int[] {1, 2, 3}; //格式三：具体存储的数字是1，2，3 int[] arr3 = {1, 2, 3}; ...
Java中的数组类型
m0_46189068的博客
08-02 4021
Java中的数组从运行机制上是没有多维的，但是Java中支持多维结构的语法，下面我们就来谈一下Java中的一位数组个多维数组 一.一维数组 1.数组的理解 数组(Array)，是多个相同类型数据按一定顺序排列 的集合，并使用一个名字命名，并通过编号的方式 对这些数据进行统一管理。 2.数组的初始化 一维数组的初始化分为静态初始化和动态初始化，静态初始化是在定义数组的同时给出数组元素的值，而动态初始化只是制定了数组的长度没有去给定数组的值，当然在数组中，初始化的时候，不能既给定了数组的长度，又给数组赋值
Java数组类型
HHYZBC的博客
04-26 4732
数组的概述 数组(Array)，是多个相同类型数据按一定顺序排列 的集合，并使用一个名字命名，并通过编号的方式 对这些数据进行统一管理。 数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括 基本数据类型和引用数据类型。 创建数组对象会在内存中开辟一整块连续的空间，而数组名中引用的是 这块连续空间的首地址。 数组的长度一旦确定，就不能修改。 我们可以直接通过下标(或索引)的方式调用指定位置的元素，速度很快。 数组的分类： 按照维度：一维数组、二维数组、三维数组、… 按照元素的数据类
JAVA 中的数组格式
yyyaif的博客
04-26 1263
java基础 java中的数组格式2
链表刷题集
最新发布
yajunjiao的专栏
04-30 904
本文主要列举了一些刷的题，不多，有那么几道，也建议各位去建立自己的刷题集。积少成多。
java中文数组
05-30
在Java中，字符数组中可以存储中文字符。下面是一个示例代码： ```java char[] chineseArray = {'中', '国', '人'}; ``` 也可以使用字符串来表示中文字符数组： ```java String[] chineseArray = {"中", "国", "人"}; ``` 需要注意的是，在Java中，一个汉字通常占用两个字符的空间。因此，如果使用字符数组存储中文字符，需要确保数组长度足够存储所有字符。而使用字符串数组则不需要考虑这个问题。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值