Java基本语法（七）：数组

最新推荐文章于 2023-03-23 16:50:43 发布
最新推荐文章于 2023-03-23 16:50:43 发布
阅读量510 收藏 1
点赞数
分类专栏： Java SE：基础 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44800710/article/details/121205064
版权

数组的相关概念

        1.概述：数组(Array)，是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。

        2.数组的常见概念

                1.数组名

                2.下标(或索引)

                3.元素

                4.数组的长度：（元素的个数）

       3.数组的特点:

                1.数组是有序排列的

               2.组属于引用数据类型的变量。数组的元素既可以是基本数据类型，也可以是引用数据类型

                3.创建数组对象会在内存中开辟一整块连续的空间

                4.数组的长度一旦确定，就不能修改。

        4．数组的分类;

                1.按照维数:一维数组、二维数组 。。。

                2.按照数组元素的类型。基本数据类型元素的数组、引用数据类型元素的数组

        5.一维数组的使用

                1.一维数组的声明和初始化

                        声明：类型[] 变量名;

                        初始化方式一（静态初始化）：变量名 =  new 类型[]{元素1,元素2,...};(数组的初始化和数组元素的赋值操作同时进行)

                        初始化方式二（动态初始化）： 变量名 =  new 类型[数组长度];(数组的初始化和数组元素的赋值操作分开进行)

                2.如何调用数组的指定位置的元素

                        通过角标的方式调用(从0开始，到长度-1结束)

                3.如何获取数组的长度

                        数组名.length

                4.如何遍历数组

for (int i = 0;i < names.length;i++){
            System.out.println(names[i]);
        }

                5.数组元素的默认初始化值

                        1.基本数据类型：

                                整型数组默认的值：0

                                浮点型数组默认的值：0.0

                                char型数组默认的值：0或'\u0000',而非'0'

                                Boolean型数组默认的值：false

                         2.引用数据类型：数组默认的值：null

                6.数组的内存解析

                        栈：存放局部变量

                        堆：存放 new 的内容

        6.多维数组的使用

                规定:二维数组分为外层数组的元素，内层数组的元素

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

                        外层元素:arr[0], arr[1]等

                        内层元素:arr[0][0] , arr[1][2]等

                1.数组元素的默认初始化值

                        1.针对于初始化方式一:比如:int[][] anr = new int[4][3];

                                外层元素的初始化值为:地址值

                                内层元素的初始化值为:与一维数组初始化情况相同

                        2.针对于初始化方式二:比如:int[][]arr = new int[4][];

                                外层元素的初始化值为:null

                                内层元素的初始化值为:不能调用，否则报错

案例（一维数组）

        /*
        从键盘读入学生成绩,找出最高分,并输出学生成绩等级。
        成绩>=最高分-10  等级为·A,
        成绩>=最高分-20  等级为·B,
        成绩>=最高分-30  等级为’C,
        其余            等级为’D
        提示:先读入学生人数,根据人数创建int数组，存放学生成绩。
        */

        Scanner scan = new Scanner(System.in);

        //获取学生人数
        System.out.println("请输入学生人数: ");
        int studentCount = scan.nextInt();

        //建立数组
        int[] scores = new int[studentCount];

        //将成绩写入数组
        int maxScores = 0;
        System.out.println("请输入" + studentCount  + "个学生成绩: ");
        for (int i = 0;i < scores.length;i++){
            scores[i] = scan.nextInt();
            if (maxScores < scores[i]) {
                maxScores = scores[i];
            }
        }

        //求出最大成绩
        /*int maxScores = 0;
        for (int i = 0;i < scores.length;i++){
            if (maxScores < scores[i]){
                maxScores = scores[i];
            }
        }*/

        //输出结果
        char level;
        for (int i = 0;i < scores.length;i++){
            if (maxScores - scores[i] <= 10){
                level = 'A';
            }else if (maxScores - scores[i] <= 20){
                level = 'B';
            }else if (maxScores - scores[i] <= 30){
                level = 'C';
            }else {
                level = 'D';
            }
            System.out.println("student " + i + " scores is " + scores[i] + ",grade is " + level);
        }

案例（多维数组）

        /*
        使用二维数组打印一个10行杨辉三角。
        【提示】
        1.第一行有1个元素,第n行有n个元素
        2.每一行的第一个元素和最后一个元素都是1
        3.从第三行开始,对于非第一个元素和最后一个元素的元素。即:
        yanghui[i][j]= yanghui[i-1][j-1] + yanghui[i-1][j];
         */

        //1.声明并初始化二维数组
        int[][] yangHui = new int[10][];

        //2.给数组的元素赋值
        for (int i = 0;i < yangHui.length;i++){
            yangHui[i] = new int[i + 1];

            //2.1给首末元素赋值
            yangHui[i][0] = 1;
            yangHui[i][i] = 1;
            //2.2给每行的非首末元素赋值
            if (i > 1){
                for (int j = 1;j < yangHui[i].length - 1;j++){
                    yangHui[i][j]= yangHui[i-1][j-1] + yangHui[i-1][j];
                }
            }

        }

        //3.遍历二维数组
        for (int i = 0;i < yangHui.length;i++){
            for (int j = 0;j < yangHui[i].length;j++){
                System.out.print(yangHui[i][j] + " ");
            }
            System.out.println();
        }

数组中常见的算法

        1.数组元素的赋值(杨辉三角、回形数等)

        2.求数值型数组中元素的最大值、最小值、平均数、总和等

        3.数组的复制、反转、查找(线性查找、二分法查找)

        4.数组元素的排序算法（内部排序（内存）和外部排序（磁盘））

 

案例（求数值型数组中元素的最大值、最小值、平均数、总和等）

        /*
        算法的考查:求数值型数组中元素的最大值、最小值、平均数、总和等
        定义一个int型的一维数组，包含10个元素，分别赋一些随机整数，
        然后求出所有元素的最大值，最小值，和值，平均值，并输出出来。
        要求:所有随机数都是两位数。
         */
        int[] arr = new int[10];

        for (int i = 0;i < arr.length;i++){
            arr[i] = (int) (Math.random() * 90 + 10);
        }

        for (int i = 0;i < arr.length;i++){
            System.out.print(arr[i] + "\t");
        }
        System.out.println();

        //求最大值
        int max = arr[0];
        for (int i = 1;i < arr.length;i++){
            if (max < arr[i]){
                max = arr[i];
            }
        }
        System.out.println("最大值为：" + max);

        //求最小值
        int min = arr[0];
        for (int i = 1;i < arr.length;i++){
            if (min > arr[i]){
                min = arr[i];
            }
        }
        System.out.println("最小值为：" + min);

        //求总值
        int number = 0;
        for (int i = 1;i < arr.length;i++){
            number += arr[i];
        }
        System.out.println("总值为：" + number);

        //求平均值
        double avg = number/arr.length;
        System.out.println("平均值为：" + avg);

案例（数组的复制、反转、查找）

     复制

        /*
        使用简单数组
        (1)创建一个名为ArrayTest的类，在main()方法中声明array1和array2两个变量
        他们是int[]类型的数组。
        (2)使用大括号{}，把array1初始化为8个素数。2,3,5,7,11,13,17,19。
        (3)显示array1的内容。
        (4)赋值array2变量等于array1，修改array2中的偶索引元素，
        使其等于索引值(如array[0]=0 ,array[2]=2)。打印出array1.
         */
        int[] array1;
        int[] array2;
        array1 = new int[]{2,3,5,7,11,13,19};

        for (int i = 0;i < array1.length;i++){
            System.out.print(array1[i] + "\t");
        }

        System.out.println();

        //数组的复制
        array2 = new int[array1.length];
        for (int i = 0;i < array2.length;i++){
            array2[i] = array1[i];
        }
        for (int i = 0;i < array2.length;i++){
            if(i % 2 == 0){
                array2[i] = i;
            }
        }

        for (int i = 0;i < array1.length;i++){
            System.out.print(array1[i] + "\t");
        }
        System.out.println();
        for (int i = 0;i < array2.length;i++){
            System.out.print(array2[i] + "\t");
        }

     反转

        /*
        反转
         */
        String[] array1 = new String[]{"AA","BB","CC","DD","EE","FF"};

        for (int i = 0;i < array1.length / 2;i++){
            String temp = array1[i];
            array1[i] = array1[array1.length - i - 1];
            array1[array1.length - i - 1] = temp;
        }
        for (int i = 0;i < array1.length;i++){
            System.out.print(array1[i] + "\t");
        }

     查找（线性查找）

        /*
        查找
         */
        String[] array1 = new String[]{"AA","BB","CC","DD","EE","FF"};
        String desc = "CC";
        boolean isFlag = true;
        for (int i = 0;i < array1.length;i++){
            if (desc.equals(array1[i])){
                System.out.println("找到了，位置为：" + i);
                isFlag = false;
                break;
            }
        }
        if (isFlag){
            System.out.println("没有找到！");
        }

     查找（二分法查找（前提：有序））

        int[] array = new int[]{-32,-14,3,26,47,78,89,145,568};

        int desc = 3;
        boolean isFlag = true;
        int head = 0;   //首索引
        int end = array.length -1;  //尾索引

        while (head <= end){
            int middle = (head + end) / 2;
            if(desc == array[middle]){
                System.out.println("找到了，位置为：" + middle);
                isFlag = false;
                break;
            }else if (desc < array[middle]){
                end = middle - 1;
            }else {
                head = middle + 1;
            }
        }
        if (isFlag){
            System.out.println("没有找到！");
        }

案例（数组元素的排序算法）

     冒泡排序

        int[] arr = new int[]{21,12,34,53,66,25,54,85,43};

        //冒泡排序
        for (int i = 0;i < arr.length - 1;i++){
            for (int j = 0;j < arr.length - 1 - i;j++){
                if (arr[j] > arr[j + 1]){
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        for (int i = 0;i < arr.length;i++){
            System.out.print(arr[i] + "\t");
        }

排序算法性能对比

Arrays工具类

        提供了大量封装好的方法

数组使用中的常见异常 

        1．数组角标越界的异常:ArrayIndexOutOfBoundsExcetion

        2．空指针异常:NullPointerException

怜宇惜乐
关注
专栏目录
JAVA语言程序设计：数组.ppt
06-23
在Java中，定义一维数组有两种语法： 1. `type arrayName[];` 或 2. `type[] arrayName;` 例如，我们可以定义一个整型数组`int intArray[];`或`int[] intArray;`。不过，这样的定义仅声明了数组变量，并未分配实际...
【shell】实现素数筛
明朗晨光的专栏
10-10 596
求一定范围内的素数和。 采用线性筛实现 1、传入两个参数 1） 第一个为起始数字start_num（包含该数字） 2） 第二个为终止数字end_num(包含该数字) 2、如果start_num小于 0，则起始数从 0 开始 3、输出该范围内的所有素数的和 4、使用方式bash Prime.sh 0 100 #!/bin/bash declare -a prime #定义数组，也可不定义 sum=0 function usage() { printf "...
c语言将数组初始化为1_C语言中数组初始化的三种方式是什么？
weixin_39724889的博客
01-13 2399
C语言中，数组初始化的方式主要有三种：1、声明时，使用 {0} 初始化；2、使用memset；3、用for循环赋值。那么，这三种方法的原理以及效率如何呢？ 请看下面的测试代码：#define ARRAY_SIZE_MAX (1*1024*1024)void function1(){char array[ARRAY_SIZE_MAX] = {0}; //声明时使用{0}初始化为全0}void f...
数组元素全部初始化为同一值问题
Mr.zhou
08-14 1万+
一：用memset初始化 二：定义数据类型时直接初始化 #include #include using namespace std; int main() { int a[10],b[10],c[10]; bool map[10][10]; memset(a,0x3f,sizeof(a)); a[2]=0x3f3f3f3f; memset(map,fals
C语言数组初始化为一个数字的技巧
热门推荐
逍遥云中鸟
01-10 2万+
C语言中，当我们使用数组的时候，我们或许会希望数组一开始全部被赋予某个特殊的值，我们该怎么做呢？ 1.全部赋值为0 int main() { int c[5]={0};//这种办法很简便，但好像只对赋值为 0 才有效，其它的数字都只会给下标为0的赋值 for(int i=0;i<5;i++) printf("%d ",c[i]); return 0; } //输出结果： 0 ...
c语言将数组初始化为1_C语言数组的初始化表示方法
weixin_42342882的博客
12-23 979
展开全部C语言数组的初始化表示方法有4种，分别是：1、定义的同时进行32313133353236313431303231363533e58685e5aeb931333365646364初始化，我们同样用数组的初始化引出结构体的初始化，我们知道数组在定义的同时进行初始化的代码如下：int nums[] = {1, 3, 5}；由此可推出结构体在定义的同时进行初始化的代码如下：struct Perso...
04_Java基础语法_（数组）_讲义
02-15
数组是Java编程中的基本概念，是存储同一类型数据集合的一种方式。本讲义将深入探讨Java中的数组及其相关知识。 一、数组的基本概念 在Java中，数组是一种特殊的对象，它能存储固定数量的同类型元素。数组的长度在...
Java语言程序设计课件：数组.ppt
09-21
Java 语言中的数组是一种强大的数据结构，用于存储同类型的多个数据项。数组提供了一种高效且有序的方式来管理和访问数据，特别是在处理批量数据时。数组分为一维数组和多维数组，这里我们将详细讨论这两个概念。 ...
Java 数组ArrayList常用语法详解
08-25
Java 数组ArrayList常用语法详解 Java 数组ArrayList是Java编程语言中最常用的数据结构之一，用于存储和操作数据。下面是ArrayList的常用语法详解： 一、导入ArrayList 首先，需要在Java程序中导入ArrayList类，...
初始java~数组1(数组的基本概念)
qq_64022781的博客
11-04 1610
初始java~数组1(数组的基本概念)
【C++】初始化一个全为1的数组
最新发布
泥嚎！
03-23 4525
[c++]初始化一个全为1的数组
Java 数组及相关习题
m0_63611404的博客
04-14 876
文章目录数组什么是数组？（数组其实是一种数据结构）什么是数据结构？数组的创建与初始化数据的静态初始化数组的使用数组和方法之间的关系关于应用数据类型的理解问题栈堆 数组 什么是数组？（数组其实是一种数据结构） 一个定义N个相同数据类型的变量，我们就把这种结构称之为数组，数组作为第一个引用数据类型 什么是数据结构？ 把一堆数字保存起来的结构就是数据结构，数据结构关心的是如何高效的读写数据 数组的创建与初始化 int[] arr = new int[]{1,2,3,4};//初始化数组时，每个元素同时赋值 in
新建一个长度为100的数组, 并且每一项都是1
飞驰的地铁
07-10 4892
fill() 填充let arr = [] arr.length = 100 // 或arr = Array(100) arr.fill(1) 循环let arr = [] for(let i = 0; i < 100; i++){ arr[i] = 1 } 字符串repeatlet arr = [...'1'.repeat(100)].map(Number) 同样字符串...
numpy学习笔记
weixin_45515116的博客
10-01 500
numpy学习笔记 一、list 和 ndarray 对比 list 分散存储，使用指针; ndarray 存在连续均匀的内存中; 使用 y = x * 2，而是使用x *= 2 （避免隐式拷贝) 二、numpy 中两个重要对象 ndarray（N-dimensional array object），多维数组 ufunc（universal function object），对多维数组的操作 三、ndarray ndarray 实际上是多维数组的含义。在 NumPy 数组中，维数称为秩（rank），
JAVA数组批量设值(初始化)的办法
柳鲲鹏
11-01 4816
　　今天看到初始化代码，通过for循环给一个数组初始化。吾一看就觉得很愚昧。心想肯定有更好办法。于是上网搜索，果然找到了办法： Arrays.fill(arr, value); 　　实际上，即使没有提供这个方法，也有两个思路： 初始化一个默认的数组，每次使用System.arrayCopy(). 可以使用增长式初始化，开始初始化一个，然后使用ystem.arrayCopy().以倍数增长...
Java 二维数组
WihauShe's Blogger
01-02 426
声明   1、int[][] arr   2、int arr[][]   3、int[] arr[] 实例化 arr = new int[][] arr = new int[10][] arr = new int[10][10] 定义并赋值：int[][] arr2 = {{1,2,3},{4,5},{7,8,9,10}}; 遍历 &...
java中初始化数组的方法
冰雪世界
03-12 8993
1.一维数组初始化 方式一： int[] array = new int[3]; array[0] = 1; array[1] = 2; array[2] = 3; 注：此种方式创建的数组，如不显式初始化数组元素，则各元素为当前数据类型的默认值。基本数据类型为0，对象类型为null。所以使用前需要将各元素显式赋值。 方式二： int[] array = new int[]{1, 2, 3}; 注：此方式与方式一的结果相同，但是更简便。 方式三： int[] array = {1, 2, 3}; 注：此
Java 如何将数组所有元素转换成一个数
tanxinji的博客
02-08 3862
 只适用于数组每一个下标存的是一位数，并且是有序的，如某个数组存的是 百十个位，或者个十百位。 一、将数组元素转换成一个数  设num是要转换的数 num = num*10 + array[i] ; i = 0~n-1。 乘以十是为了提高数的位数，每次加的数组元素是当前num的个位。从在数组中所认为的数的个位开始加。  代码示例: public class Test { public static void main(String[] args) { int array[] = {5
Java基本语法：数组元素默认值与变量声明
接下来，我们简要回顾一下Java基本语法的其他重要概念： - **关键字**：是Java语言预定义的具有特定意义的字符串，例如`public`、`private`、`if`、`for`等。它们不能用作变量名、类名或方法名。 - **标识符**：...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值