热门标签
当前位置: article > 正文
JAVA数组总结
作者：繁依Fanyi0 | 2024-07-03 10:14:20
赞
踩
JAVA数组总结
数组
为什么需要数组
需要统计某公司50个员工的工资情况，例如计算平均工资、找到最高工资等。用之前知识，首先需要声明50个变量来分别记录每位员工的工资，这样会很麻烦。因此我们可以将所有的数据全部存储到一个容器中统一管理，并使用容器进行计算。
数组的概念
- 数组(Array)，是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。
- 数组中的概念
- 数组名
- 下标（或索引）
- 元素
- 数组的长度
- 1
- 2
- 3
- 4
- 5
数组的特点：
- 数组本身是`引用数据类型`，而数组中的元素可以是`任何数据类型`，包括基本数据类型和引用数据类型。
- 创建数组对象会在内存中开辟一整块`连续的空间`。占据的空间的大小，取决于数组的长度和数组中元素的类型。
- 数组中的元素在内存中是依次紧密排列的，有序的。
- 数组，一旦初始化完成，其长度就是确定的。数组的`长度一旦确定，就不能修改`。
- 我们可以直接通过下标(或索引)的方式调用指定位置的元素，速度很快。
- 数组名中引用的是这块连续空间的首地址。
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
数组的分类
1、按照元素类型分：
- 基本数据类型元素的数组：每个元素位置存储基本数据类型的值
- 引用数据类型元素的数组：每个元素位置存储对象（本质是存储对象的首地址）（在面向对象部分讲解）
- 1
- 2
2、按照维度分：
- 一维数组：存储一组数据
- 二维数组：存储多组数据，相当于二维表，一行代表一组数据，只是这里的二维表每一行长度不要求一样。
- 1
- 2
一维数组的使用
一维数组的声明
格式：
//推荐
元素的数据类型[] 一维数组的名称;
//不推荐
元素的数据类型 一维数组名[];
- 1
- 2
- 3
- 4
- 5
举例：
int[] arr;
int arr1[];
double[] arr2;
String[] arr3; //引用类型变量数组
- 1
- 2
- 3
- 4
数组的声明，需要明确：
（1）数组的维度：在Java中数组的符号是[]，[]表示一维，\[]\[]表示二维。
（2）数组的元素类型：即创建的数组容器可以存储什么数据类型的数据。元素的类型可以是任意的Java的数据类型。例如：int、String、Student等。
（3）数组名：就是代表某个数组的标识符，数组名其实也是变量名，按照变量的命名规范来命名。数组名是个引用数据类型的变量，因为它代表一组数据。
- 1
- 2
- 3
举例：
public class ArrayTest1 { public static void main(String[] args) { //比如，要存储一个小组的成绩 int[] scores; int grades[]; // System.out.println(scores);//未初始化不能使用 //比如，要存储一组字母 char[] letters; //比如，要存储一组姓名 String[] names; //比如，要存储一组价格 double[] prices; } }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
注意：Java语言中声明数组时不能指定其长度(数组中元素的个数)。 例如： int a[5]; //非法
一维数组的初始化
静态初始化
- 如果数组变量的初始化和数组元素的赋值操作同时进行，那就称为静态初始化。
- 静态初始化，本质是用静态数据（编译时已知）为数组初始化。此时数组的长度由静态数据的个数决定。
- 1
- 2
- 一维数组声明和静态初始化格式1：
数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3,...};
或
数据类型[] 数组名;
数组名 = new 数据类型[]{元素1,元素2,元素3,...};
- 1
- 2
- 3
- 4
new：关键字，创建数组使用的关键字。因为数组本身是引用数据类型，所以要用new创建数组实体。
int[] arr = new int[]{1,2,3,4,5};//正确
//或
int[] arr;
arr = new int[]{1,2,3,4,5};//正确
- 1
- 2
- 3
- 4
一维数组声明和静态初始化格式2：
数据类型[] 数组名 = {元素1,元素2,元素3...};//必须在一个语句中完成，不能分成两个语句写
- 1
例如，定义存储1，2，3，4，5整数的数组容器
int[] arr = {1,2,3,4,5};//正确
int[] arr;
arr = {1,2,3,4,5};//错误
- 1
- 2
- 3
举例：
public class ArrayTest2 { public static void main(String[] args) { int[] arr = {1,2,3,4,5};//右边不需要写new int[] int[] nums; nums = new int[]{10,20,30,40}; //声明和初始化在两个语句完成，就不能使用new int[] char[] word = {'h','e','l','l','o'}; String[] heros = {"袁隆平","邓稼先","钱学森"}; System.out.println("arr数组：" + arr);//arr数组：[I@1b6d3586 System.out.println("nums数组：" + nums);//nums数组：[I@4554617c System.out.println("word数组：" + word);//word数组：[C@74a14482 System.out.println("heros数组：" + heros);//heros数组：[Ljava.lang.String;@1540e19d } }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
动态初始化
数组变量的初始化和数组元素的赋值操作分开进行，即为动态初始化。
动态初始化中，只确定了元素的个数（即数组的长度），而元素值此时只是默认值，还并未真正赋自己期望的值。真正期望的数据需要后续单独一个一个赋值。
- 1
- 2
格式：
数组存储的元素的数据类型[] 数组名字 = new 数组存储的元素的数据类型[长度];
或
数组存储的数据类型[] 数组名字;
数组名字 = new 数组存储的数据类型[长度];
- 1
- 2
- 3
- 4
- [长度]：数组的长度，表示数组容器中可以最多存储多少个元素。
- **注意：数组有定长特性，长度一旦指定，不可更改。**和水杯道理相同，买了一个2升的水杯，总容量就是2升是固定的。
举例1：正确写法
int[] arr = new int[5];
int[] arr;
arr = new int[5];
- 1
- 2
- 3
举例2：错误写法
int[] arr = new int[5]{1,2,3,4,5};//错误的，后面有{}指定元素列表，就不需要在[]中指定元素个数了。
- 1
一维数组的使用
数组的长度
- 数组的元素总个数，即数组的长度
- 每个数组都有一个属性length指明它的长度，例如：arr.length 指明数组arr的长度(即元素个数)
- 每个数组都具有长度，而且一旦初始化，其长度就是确定，且是不可变的。
- 1
- 2
- 3
数组元素的引用
如何表示数组中的一个元素？
每一个存储到数组的元素，都会自动的拥有一个编号，从0开始，这个自动编号称为数组索引(index)或下标，可以通过数组的索引/下标访问到数组中的元素。
数组名[索引/下标]
- 1
数组的下标范围？
Java中数组的下标从[0]开始，下标范围是[0, 数组的长度-1]，即[0, 数组名.length-1]
数组元素下标可以是整型常量或整型表达式。如a[3] , b[i] , c[6*i];
- 1
- 2
举例
public class ArrayTest3 { public static void main(String[] args) { int[] arr = {1,2,3,4,5}; System.out.println("arr数组的长度：" + arr.length); System.out.println("arr数组的第1个元素：" + arr[0]);//下标从0开始 System.out.println("arr数组的第2个元素：" + arr[1]); System.out.println("arr数组的第3个元素：" + arr[2]); System.out.println("arr数组的第4个元素：" + arr[3]); System.out.println("arr数组的第5个元素：" + arr[4]); //修改第1个元素的值 //此处arr[0]相当于一个int类型的变量 arr[0] = 100; System.out.println("arr数组的第1个元素：" + arr[0]); } }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
一维数组的遍历
将数组中的每个元素分别获取出来，就是遍历。for循环与数组的遍历是绝配。
举例1
public class ArrayTest4 {
public static void main(String[] args) {
int[] arr = new int[]{1,2,3,4,5};
//打印数组的属性，输出结果是5
System.out.println("数组的长度：" + arr.length);
//遍历输出数组中的元素
System.out.println("数组的元素有：");
for(int i=0; i<arr.length; i++){
System.out.println(arr[i]);
}
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
举例2
public class ArrayTest5 { public static void main(String[] args) { int[] arr = new int[5]; System.out.println("arr数组的长度：" + arr.length); System.out.print("存储数据到arr数组之前：["); for (int i = 0; i < arr.length; i++) { if(i==0){ System.out.print(arr[i]); }else{ System.out.print("," + arr[i]); } } System.out.println("]"); //初始化 /* arr[0] = 2; arr[1] = 4; arr[2] = 6; arr[3] = 8; arr[4] = 10; */ for (int i = 0; i < arr.length; i++) { arr[i] = (i+1) * 2; } System.out.print("存储数据到arr数组之后：["); for (int i = 0; i < arr.length; i++) { if(i==0){ System.out.print(arr[i]); }else{ System.out.print("," + arr[i]); } } System.out.println("]"); } }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
数组元素的默认值
数组是引用类型，当我们使用动态初始化方式创建数组时，元素值只是默认值。例如：
public class ArrayTest6 {
public static void main(String argv[]){
int a[]= new int[5];
System.out.println(a[3]); //a[3]的默认值为0
}
}
- 1
- 2
- 3
- 4
- 5
- 6
对于基本数据类型而言，默认初始化值各有不同。
对于引用数据类型而言，默认初始化值为null（注意与0不同！)
public class ArrayTest7 { public static void main(String[] args) { //存储26个字母 char[] letters = new char[26]; System.out.println("letters数组的长度：" + letters.length); System.out.print("存储字母到letters数组之前：["); for (int i = 0; i < letters.length; i++) { if(i==0){ System.out.print(letters[i]); }else{ System.out.print("," + letters[i]); } } System.out.println("]"); //存储5个姓名 String[] names = new String[5]; System.out.println("names数组的长度：" + names.length); System.out.print("存储姓名到names数组之前：["); for (int i = 0; i < names.length; i++) { if(i==0){ System.out.print(names[i]); }else{ System.out.print("," + names[i]); } } System.out.println("]"); } }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
一维数组的应用
**案例：**从键盘读入学生成绩，找出最高分，并输出学生成绩等级。
-
成绩>=最高分-10 等级为’A’
-
成绩>=最高分-20 等级为’B’
-
成绩>=最高分-30 等级为’C’
-
其余 等级为’D’
提示：先读入学生人数，根据人数创建int数组，存放学生成绩。
public class ScoreTest1 { public static void main(String[] args) { //1. 根据提示，获取学生人数 System.out.print("请输入学生人数："); Scanner scanner = new Scanner(System.in); int count = scanner.nextInt(); //2. 根据学生人数，创建指定长度的数组 (使用动态初始化) int[] scores = new int[count]; //3. 使用循环，依次给数组的元素赋值 int maxScore = 0; //记录最高分 System.out.println("请输入" + count + "个成绩"); for (int i = 0; i < scores.length; i++) { scores[i] = scanner.nextInt(); //4. 获取数组中元素的最大值，即为最高分 if(maxScore < scores[i]){ maxScore = scores[i]; } } System.out.println("最高分是：" + maxScore); //5. 遍历数组元素，输出各自的分数，并根据其分数与最高分的差值，获取各自的等级 char grade; for (int i = 0; i < scores.length; i++) { if(scores[i] >= maxScore - 10){ grade = 'A'; }else if(scores[i] >= maxScore - 20){ grade = 'B'; }else if(scores[i] >= maxScore - 30){ grade = 'C'; }else{ grade = 'D'; } System.out.println("student " + i + " socre is " + scores[i] + ", grade is " + grade); } //关闭资源 scanner.close(); } }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
多维数组的使用
概述
-
Java 语言里提供了支持多维数组的语法。
-
如果说可以把一维数组当成几何中的
线性图形，那么二维数组就相当于是一个表格，像Excel中的表格、围棋棋盘一样。 -
应用举例1：
某公司2022年全年各个月份的销售额进行登记。按月份存储，可以使用一维数组。如下：
int[] monthData = new int[]{23,43,22,34,55,65,44,67,45,78,67,66};- 1
如果改写为按
季度为单位存储怎么办呢？int[][] quarterData = new int[][]{{23,43,22},{34,55,65},{44,67,45},{78,67,66}};- 1
- 应用举例2：
高一年级三个班级均由多个学生姓名构成一个个数组。如下：
String[] class1 = new String[]{"段誉","令狐冲","任我行"};
String[] class2 = new String[]{"张三丰","周芷若"};
String[] class3 = new String[]{"赵敏","张无忌","韦小宝","杨过"};
- 1
- 2
- 3
- 4
- 5
- 6
那从整个年级看，我们可以声明一个二维数组。如下：
String[][] grade = new String[][]{{"段誉","令狐冲","任我行"},{"张三丰","周芷若"},{"赵敏","张无忌","韦小宝","杨过"}};
- 1
声明
二维数组声明的语法格式：
//推荐
元素的数据类型[][] 二维数组的名称;
//不推荐
元素的数据类型 二维数组名[][];
//不推荐
元素的数据类型[] 二维数组名[];
- 1
- 2
- 3
- 4
- 5
- 6
- 7
例如：
public class Test20TwoDimensionalArrayDefine {
public static void main(String[] args) {
//存储多组成绩
int[][] grades;
//存储多组姓名
String[][] names;
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
面试：
int[] x, y[];
//x是一维数组，y是二维数组
- 1
- 2
静态初始化
格式：
int[][] arr = new int[][]{{3,8,2},{2,7},{9,0,1,6}};
- 1
定义一个名称为arr的二维数组，二维数组中有三个一维数组
- 每一个一维数组中具体元素也都已初始化
- 第一个一维数组 arr[0] = {3,8,2};
- 第二个一维数组 arr[1] = {2,7};
- 第三个一维数组 arr[2] = {9,0,1,6};
- 第三个一维数组的长度表示方式：arr[2].length;
- 注意特殊写法情况：int[] x,y[]; x是一维数组，y是二维数组。
- 举例1：
int[][] arr = {{1,2,3},{4,5,6},{7,8,9,10}};//声明与初始化必须在一句完成
int[][] arr = new int[][]{{1,2,3},{4,5,6},{7,8,9,10}};
int[][] arr;
arr = new int[][]{{1,2,3},{4,5,6},{7,8,9,10}};
arr = new int[3][3]{{1,2,3},{4,5,6},{7,8,9,10}};//错误，静态初始化右边new 数据类型[][]中不能写数字
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 举例2：
public class TwoDimensionalArrayInitialize { public static void main(String[] args) { //存储多组成绩 int[][] grades = { {89,75,99,100}, {88,96,78,63,100,86}, {56,63,58}, {99,66,77,88} }; //存储多组姓名 String[][] names = { {"张三","李四", "王五", "赵六"}, {"刘备","关羽","张飞","诸葛亮","赵云","马超"}, {"曹丕","曹植","曹冲"}, {"孙权","周瑜","鲁肃","黄盖"} }; } }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
动态初始化
如果二维数组的每一个数据，甚至是每一行的列数，需要后期单独确定，那么就只能使用动态初始化方式了。动态初始化方式分为两种格式：
格式1：规则二维表：每一行的列数是相同的
//（1）确定行数和列数
元素的数据类型[][] 二维数组名 = new 元素的数据类型[m][n];
//其中，m:表示这个二维数组有多少个一维数组。或者说一共二维表有几行
//其中，n:表示每一个一维数组的元素有多少个。或者说每一行共有一个单元格
//此时创建完数组，行数、列数确定，而且元素也都有默认值
//（2）再为元素赋新值
二维数组名[行下标][列下标] = 值;
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
举例：
int[][] arr = new int[3][2];
- 1
-
定义了名称为arr的二维数组
-
二维数组中有3个一维数组
-
每一个一维数组中有2个元素
-
一维数组的名称分别为arr[0], arr[1], arr[2]
-
给第一个一维数组1脚标位赋值为78写法是：
arr[0][1] = 78;
格式2：不规则：每一行的列数不一样
//（1）先确定总行数
元素的数据类型[][] 二维数组名 = new 元素的数据类型[总行数][];
//此时只是确定了总行数，每一行里面现在是null
//（2）再确定每一行的列数，创建每一行的一维数组
二维数组名[行下标] = new 元素的数据类型[该行的总列数];
//此时已经new完的行的元素就有默认值了，没有new的行还是null
//(3)再为元素赋值
二维数组名[行下标][列下标] = 值;
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
举例：
int[][] arr = new int[3][];
- 1
- 二维数组中有3个一维数组。
- 每个一维数组都是默认初始化值null (注意：区别于格式1）
- 可以对这个三个一维数组分别进行初始化：arr[0] = new int[3]; arr[1] = new int[1]; arr[2] = new int[2];
- 注：
int[][]arr = new int[][3];//非法
练习：
/* 1 2 2 3 3 3 4 4 4 4 5 5 5 5 5 */ public class Test25DifferentElementCount { public static void main(String[] args){ //1、声明一个二维数组，并且确定行数 //因为每一行的列数不同，这里无法直接确定列数 int[][] arr = new int[5][]; //2、确定每一行的列数 for(int i=0; i<arr.length; i++){ /* arr[0] 的列数是1 arr[1] 的列数是2 arr[2] 的列数是3 arr[3] 的列数是4 arr[4] 的列数是5 */ arr[i] = new int[i+1]; } //3、确定元素的值 for(int i=0; i<arr.length; i++){ for(int j=0; j<arr[i].length; j++){ arr[i][j] = i+1; } } //4、遍历显示 for(int i=0; i<arr.length; i++){ for(int j=0; j<arr[i].length; j++){ System.out.print(arr[i][j] + " "); } System.out.println(); } } }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
数组的长度和角标
- 二维数组的长度/行数：二维数组名.length
- 二维数组的某一行：二维数组名[行下标]，此时相当于获取其中一组数据。它本质上是一个一维数组。行下标的范围：[0, 二维数组名.length-1]。此时把二维数组看成一维数组的话，元素是行对象。
- 某一行的列数：二维数组名[行下标].length，因为二维数组的每一行是一个一维数组。
- 某一个元素：二维数组名[行下标][列下标]，即先确定行/组，再确定列。
public class Test22TwoDimensionalArrayUse { public static void main(String[] args){ //存储3个小组的学员的成绩，分开存储，使用二维数组。 /* int[][] scores1; int scores2[][]; int[] scores3[];*/ int[][] scores = { {85,96,85,75}, {99,96,74,72,75}, {52,42,56,75} }; System.out.println(scores);//[[I@15db9742 System.out.println("一共有" + scores.length +"组成绩."); //[[：代表二维数组，I代表元素类型是int System.out.println(scores[0]);//[I@6d06d69c //[：代表一维数组，I代表元素类型是int System.out.println(scores[1]);//[I@7852e922 System.out.println(scores[2]);//[I@4e25154f //System.out.println(scores[3]);//ArrayIndexOutOfBoundsException: 3 System.out.println("第1组有" + scores[0].length +"个学员."); System.out.println("第2组有" + scores[1].length +"个学员."); System.out.println("第3组有" + scores[2].length +"个学员."); System.out.println("第1组的每一个学员成绩如下："); //第一行的元素 System.out.println(scores[0][0]);//85 System.out.println(scores[0][1]);//96 System.out.println(scores[0][2]);//85 System.out.println(scores[0][3]);//75 //System.out.println(scores[0][4]);//java.lang.ArrayIndexOutOfBoundsException: 4 } }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
二维数组的遍历
- 格式：
for(int i=0; i<二维数组名.length; i++){ //二维数组对象.length
for(int j=0; j<二维数组名[i].length; j++){//二维数组行对象.length
System.out.print(二维数组名[i][j]);
}
System.out.println();
}
- 1
- 2
- 3
- 4
- 5
- 6
- 举例：
public class Test23TwoDimensionalArrayIterate { public static void main(String[] args) { //存储3个小组的学员的成绩，分开存储，使用二维数组。 int[][] scores = { {85,96,85,75}, {99,96,74,72,75}, {52,42,56,75} }; System.out.println("一共有" + scores.length +"组成绩."); for (int i = 0; i < scores.length; i++) { System.out.print("第" + (i+1) +"组有" + scores[i].length + "个学员，成绩如下："); for (int j = 0; j < scores[i].length; j++) { System.out.print(scores[i][j]+"\t"); } System.out.println(); } } }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
内存解析
二维数组本质上是元素类型是一维数组的一维数组。
int[][] arr = {
{1},
{2,2},
{3,3,3},
{4,4,4,4},
{5,5,5,5,5}
};
- 1
- 2
- 3
- 4
- 5
- 6
- 7
//1、声明二维数组，并确定行数和列数
int[][] arr = new int[4][5];
//2、确定元素的值
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr.length; j++) {
arr[i][j] = i + 1;
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
//1、声明一个二维数组，并且确定行数 //因为每一行的列数不同，这里无法直接确定列数 int[][] arr = new int[5][]; //2、确定每一行的列数 for(int i=0; i<arr.length; i++){ /* arr[0] 的列数是1 arr[1] 的列数是2 arr[2] 的列数是3 arr[3] 的列数是4 arr[4] 的列数是5 */ arr[i] = new int[i+1]; } //3、确定元素的值 for(int i=0; i<arr.length; i++){ for(int j=0; j<arr[i].length; j++){ arr[i][j] = i+1; } }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
应用举例
案例1： 获取arr数组中所有元素的和。
提示：使用for的嵌套循环即可。
**案例2：**声明：int[] x,y[]; 在给x,y变量赋值以后，以下选项允许通过编译的是：
声明：int[] x,y[]; 在给x,y变量赋值以后，以下选项允许通过编译的是：
a) x[0] = y; //no
b) y[0] = x; //yes
c) y[0][0] = x; //no
d) x[0][0] = y; //no
e) y[0][0] = x[0]; //yes
f) x = y; //no
提示：
一维数组：int[] x 或者int x[]
二维数组：int[][] y 或者 int[] y[] 或者 int y[][]
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
**案例3：**使用二维数组打印一个 10 行杨辉三角。
提示：
-
第一行有 1 个元素, 第 n 行有 n 个元素
-
每一行的第一个元素和最后一个元素都是 1
-
从第三行开始, 对于非第一个元素和最后一个元素的元素。即：
yanghui[i][j] = yanghui[i-1][j-1] + yanghui[i-1][j];
- 1
/** * @author 尚硅谷-宋红康 * @create 10:11 */ public class YangHuiTest { public static void main(String[] args) { //1. 动态初始化的方式创建二维数组 int[][] yangHui = new int[10][]; for (int i = 0; i < yangHui.length; i++) { yangHui[i] = new int[i + 1]; //2. 给数组元素赋值 // 2.1 给外层数组元素中的首元素和末元素赋值 yangHui[i][0] = yangHui[i][i] = 1; //2.2 给外层数组元素中的非首元素和非末元素赋值（难） //if(i > 1){ //从 i == 2 开始执行 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] + "\t"); } System.out.println(); } } }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
数组的常见算法
数值型数组特征值统计
- 这里的特征值涉及到：平均值、最大值、最小值、总和等
举例1： 数组统计：求总和、均值
public class TestArrayElementSum {
public static void main(String[] args) {
int[] arr = {4,5,6,1,9};
//求总和、均值
int sum = 0;//因为0加上任何数都不影响结果
for(int i=0; i<arr.length; i++){
sum += arr[i];
}
double avg = (double)sum/arr.length;
System.out.println("sum = " + sum);
System.out.println("avg = " + avg);
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
**举例2：**求数组元素的总乘积
public class TestArrayElementMul {
public static void main(String[] args) {
int[] arr = {4,5,6,1,9};
//求总乘积
long result = 1;//因为1乘以任何数都不影响结果
for(int i=0; i<arr.length; i++){
result *= arr[i];
}
System.out.println("result = " + result);
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
举例3： 求数组元素中偶数的个数
public class TestArrayElementEvenCount {
public static void main(String[] args) {
int[] arr = {4,5,6,1,9};
//统计偶数个数
int evenCount = 0;
for(int i=0; i<arr.length; i++){
if(arr[i]%2==0){
evenCount++;
}
}
System.out.println("evenCount = " + evenCount);
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
举例4： 求数组元素的最大值
public class TestArrayMax {
public static void main(String[] args) {
int[] arr = {4,5,6,1,9};
//找最大值
int max = arr[0];
for(int i=1; i<arr.length; i++){//此处i从1开始，是max不需要与arr[0]再比较一次了
if(arr[i] > max){
max = arr[i];
}
}
System.out.println("max = " + max);
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
举例5： 找最值及其第一次出现的下标
public class TestMaxIndex { public static void main(String[] args) { int[] arr = {4,5,6,1,9}; //找最大值以及第一个最大值下标 int max = arr[0]; int index = 0; for(int i=1; i<arr.length; i++){ if(arr[i] > max){ max = arr[i]; index = i; } } System.out.println("max = " + max); System.out.println("index = " + index); } }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
举例6： 找最值及其所有最值的下标
public class Test13AllMaxIndex { public static void main(String[] args) { int[] arr = {4,5,6,1,9,9,3}; //找最大值 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.print("最大值的下标有："); //遍历数组，看哪些元素和最大值是一样的 for(int i=0; i<arr.length; i++){ if(max == arr[i]){ System.out.print(i+"\t"); } } System.out.println(); } }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
优化
public class Test13AllMaxIndex2 { public static void main(String[] args) { int[] arr = {4,5,6,1,9,9,3}; //找最大值 int max = arr[0]; String index = "0"; for(int i=1; i<arr.length; i++){ if(arr[i] > max){ max = arr[i]; index = i + ""; }else if(arr[i] == max){ index += "," + i; } } System.out.println("最大值是" + max); System.out.println("最大值的下标是[" + index+"]"); } }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
举例7(难)： 输入一个整形数组，数组里有正数也有负数。数组中连续的一个或多个整数组成一个子数组，每个子数组都有一个和。求所有子数组的和的最大值。要求时间复杂度为O(n)。
例如：输入的数组为1, -2, 3, -10, -4, 7, 2, -5，和最大的子数组为3, 10, -4, 7, 2，因此输出为该子数组的和18。
public class Test5 { public static void main(String[] args) { int[] arr = new int[]{1, -2, 3, 10, -4, 7, 2, -5}; int i = getGreatestSum(arr); System.out.println(i); } public static int getGreatestSum(int[] arr){ int greatestSum = 0; if(arr == null || arr.length == 0){ return 0; } int temp = greatestSum; for(int i = 0;i < arr.length;i++){ temp += arr[i]; if(temp < 0){ temp = 0; } if(temp > greatestSum){ greatestSum = temp; } } if(greatestSum == 0){ greatestSum = arr[0]; for(int i = 1;i < arr.length;i++){ if(greatestSum < arr[i]){ greatestSum = arr[i]; } } } return greatestSum; } }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
举例8：评委打分
分析以下需求，并用代码实现：
（1）在编程竞赛中，有10位评委为参赛的选手打分，分数分别为：5，4，6，8，9，0，1，2，7，3
（2）求选手的最后得分（去掉一个最高分和一个最低分后其余8位评委打分的平均值）
/** * @author 尚硅谷-宋红康 * @create 10:03 */ public class ArrayExer { public static void main(String[] args) { int[] scores = {5,4,6,8,9,0,1,2,7,3}; int max = scores[0]; int min = scores[0]; int sum = 0; for(int i = 0;i < scores.length;i++){ if(max < scores[i]){ max = scores[i]; } if(min > scores[i]){ min = scores[i]; } sum += scores[i]; } double avg = (double)(sum - max - min) / (scores.length - 2); System.out.println("选手去掉最高分和最低分之后的平均分为：" + avg); } }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/繁依Fanyi0/article/detail/782765
推荐阅读
相关标签
