Java中的数组

一只小菜鸟YZXCN

已于 2022-09-17 17:21:51 修改

阅读量1.9k

点赞数 11

分类专栏： Java基础知识文章标签： java

于 2022-09-15 20:18:45 首次发布

本文链接：https://blog.csdn.net/m0_48207512/article/details/126752361

版权

Java基础知识专栏收录该内容

19 篇文章 3 订阅

订阅专栏

本文详细介绍了Java中一维数组和二维数组的基础知识，包括数组的定义、组成、命名规则、声明、分配空间、赋值以及遍历方法。同时，通过实例展示了如何在数组中查找最大值和最小值、添加元素、冒泡排序等操作。此外，还探讨了二维数组的声明、分配、赋值方式以及遍历二维数组的两种方法。文章以实际编程示例辅助理解，适合初学者学习。

摘要由CSDN通过智能技术生成

一、一维数组

1 .一维数组基础知识

定义：存储一组相同类型数据的空间

数组和变量的区别：

（1）变量中只能存储一个数据

（2）数组中可以存储多个相同类型的数据

注意：数组属于引用数据类型

2.数组组成成份

数据类型：描述的是数组中的元素类型，数组的数据元素是一组相同类型的数据

数组名：数组名的命名规则和变量名的命名规则相同

元素下标：因为数组在内存中是连续的空间，所以会给数组里的元素按照顺序进行编号，编号从0 开始，我们把这个编号叫下标(索引)

数组长度：数组中元素的数量

3.数组名的命名规则

（1）由字母、数字、下划线( _ )、美元符号($)组成

（2）不能以数字开头，不建议使用美元符号($)开头

（3）不能是关键字

（4）严格区分字母大小写

（5）采用小驼峰命名法

（6）数组命名要做到见名知意，见到数组名就知道代表的具体含义

4.数组格式

数组的声明：数据类型[ ] 数组名；或数据类型数组名[ ]；

作用：声明数组元素的类型

分配存储空间：数组名 = new 数据类型[数组长度];

作用：分配用来存储数据的空间

赋值：数组名[下标] = 数据;

作用：将数据存储到数组中

操作数据：通过数组名[下标]来操作数据对数据进行加减乘除等操作

数组的声明数组、分配空间合并写格式

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

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

数组的声明数组、分配空间、赋值合并写的简写格式

数据类型[ ] 数组名 = new 数组类型[ ]{数据元素1，数据元素2，数据元素3，数据元素n}

数据类型数组名[ ] = new 数组类型[ ]{数据元素1，数据元素2，数据元素3，数据元素n

数据类型[ ] 数组名 = {数据元素1，数据元素2，数据元素3，数据元素n}

数据类型数组名[ ] = {数据元素1，数据元素2，数据元素3，数据元素n

数据类型元素默认值

数据类型	默认初始值
byte、short、in、long	0
float、double	0.0
char	一个空字符，即 '\u0000'
boolean	false
引用数据类型	null,表示不引用任何对象

5.遍历数组：

定义：将数组中元素按照下标顺序依次输出

（1）普通for循环遍历数组

格式：

        for(int i = 0;i<数组名.length;i++){

                System.out.println(数组名[i]);

        }

（2）增强for循环遍历数组

格式：

         for(元素类型变量名:数组名){

                System.out.println(变量名);

           }

执行规律：

将数组或集合中的元素依次取出存入到变量中，然后操作变量就等同于操作数组或集合中的元素数据

注意：

1. 增强for循环执行效率要比普通for循环要高！

2.数组每把一个元素存入到变量，变量会立即输出这个数组元素的值

6.数组的应用

1. 求数组中的最大值/最小值

思路：

（1）假设数组中第一个元素（下标为0的元素）为最大值/最小值。

（2）然后依次将后面元素和假设的最大值/最小值进行比较。

（3）如果后续元素比假设的最大值/最小值大/小的话，就取代假设的最大值/最小值，成为新的最大值/最小值。

（4）比较完数组里所有的元素后，获得最大值/最小值。

例：有一组数据{ 56 ，73 ，60 ，87 ，90 ， 110， 21} 要求：选出最大值和最小值

package test;

public class Subject11 {

	public static void main(String[] args) {
		//例：有一组数据{ 56 ，73 ，60  ，87  ，90 ， 110， 21}要求：选出最大值和最小值
		
		int[] nums = {56,73,60,87,90,110,21};  //定义数组存放数据

        //求最大值
		int max = nums[0];                     //设置变量max初始值
		for(int i=0;i < nums.length; i++){     //普通for循环
			if(nums[i]>max){				   //数组元素与变量max进行比较
				max = nums[i];				   //把数组元素的最大值赋值给变量max
			}
		
		}
		System.out.println("数组元素的最大值:"+max);
		
		//求最小值
		
		int min = nums[0];                     //设置变量min初始值
		for(int i=0;i < nums.length; i++){     //普通for循环
			if(nums[i]<min){				   //数组元素与变量min进行比较
				min = nums[i];				   //把数组元素的最小值赋值给变量min
			}
		}
		System.out.println("数组元素的最大值:"+min);
		
		
	}

}

2.数组中添加元素问题·

思路：

（1）声明一个长度比原来数组长度大1的数组
（2）将原来数组里元素按照顺序存入到新的数组中
（3）使用Scanner类获取你要增加的学员成绩
（4）通过循环比较获取增加的学员成绩的插入位置
（5）插入元素插入位置开始及之后的元素依次往后移动一位（从最后一个元素开始倒着移动）
（6）将要插入的成绩存储到插入位置

例：有一组学员的成绩{99，85，82，63， 60}，已经是按降序排列。
要求：要增加一个学员的成绩，将它插入成绩序列，并保持降序

package test;

import java.util.Scanner;

public class Demo01 {

	public static void main(String[] args) {
		/*有一组学员的成绩{99，85，82，63， 60}，已经是按降序排列。
	 * 
	 * 要增加一个学员的成绩，将它插入成绩序列，并保持降序*/
		
		int[] scores = {90,85,82,63,60,50};
		//声明一个长度比原来数组长度大1的数组
		int[] newScores = new int[scores.length+1];
		//将原来数组里元素按照顺序存入到新的数组中
	    for(int i=0;i<scores.length;i++){
	    	newScores[i]=scores[i];
	    }
	   
	     //使用Scanner类获取你要增加的学员成绩
	    Scanner xs = new Scanner(System.in);
	    //从键盘输入要插入的数据
	    System.out.println("请输入要插入的学生成绩：");
	    int insert = xs.nextInt();
	    // 设置插入的成绩插入的位置，默认将其插入在数组最后位置
	    int index=newScores.length-1;
	    //通过循环比较获取增加的学员成绩的插入位置
	    for(int i = 0;i<newScores.length;i++){
	    	if(newScores[i]<insert){
	    		index=i;
	    		break;
	    	}
	    }
	    //从插入元素插入位置开始及之后的元素依次往后移动一位（从最后一个元素开始，倒着移动）
	    for (int i = newScores.length - 1; i > index; i--) {
			newScores[i] = newScores[i - 1];
		}
	    //将要插入的成绩存储到插入位置
	    newScores[index] = insert;
	   //遍历数组 输出数组里的所有元素，看一下是否满足了需求
	    for (int j :newScores) {
			System.out.print(j+" ");
		}
	}
	
}

3.冒泡排序法

思路：

（1）将数组中元素两两比较，大的数往后排（小的数）往后排（往前排）

（2）每一轮将大数（小数）排在最后面（最前面）位置。

（3）多轮比较后，得出升序（降序）排列的数组。

例：现有一个数组{20,80,60,85,90,60.98}需要进行升序排序

package test;

public class MoPo {

	public static void main(String[] args) {
		
		//定义数组
		int[] nums = {20,80,60,85,90,60,98};
		//外循环控制比较的轮数
		for(int i=0;i<nums.length-1;i++){
			//内循环控制每一轮比较的次数
			for(int j=0;j<nums.length-1-i;j++){
				//比较相邻的两个元素，如果前面的元素比后面的元素大交换元素位置
				if(nums[i]>nums[i+1]){ 
					//设置一个变量，存储数值大的元素，用来交换位置
					int temp = nums[i];
					nums[i] = nums[i+1];  
					nums[i+1] = temp;
				}
			}
		}
		//遍历数组，输出排序后的结果
		for(int k:nums){
			System.out.print(k+" ");
		}

	}

}

二、二维数组

定义：元素为一维数组的一维数组

1.语法格式:

数组声明：

数据类型[ ] [ ] 数组名；

分配空间：

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

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

赋值：

数组名[下标][下标] = 数据;

二维数组声明、分配空间合并写格式：

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

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

二维数组声明、分配空间、赋值合并写：

数组类型[ ][ ] 数组名 = { {元素1,元素2,元素n},{元素1,元素2,元素n},···,{元素1,元素2,}，{元素1,元素2,元素n} };

数组类型[ ][ ] 数组名 = new 数组类型[ ][ ] { {元素1,元素2,元素n},{元素1,元素2,元素n},···,{元素1,元素2,}，{元素1,元素2,元素n} };

注意：二为数组本质上还是一个一维数组，只是这个一维数组里的元素还是一个一维数组

2、遍历数组

（1）普通for循环结构遍历二维数组

格式：

        for(int i = 0;i<数组名.length;i++){

                for(int j = 0;j<元素数组名[i].length;j++){

                         System.out.println(数组名[i][j]);

                }

        }

（2）增强for循环结构遍历二维数组

格式：

for( 数据类型[ ] 一维数组名：二维数组名 ){

for（数据类型变量名：一维数组名）{

System.out.println(变量名);

}

}

执行规律：

（1）先定义一个一维数组，把二维数组中的元素值存入到一维数组当中

（2）将数组或集合中的元素依次取出存入到变量中，然后操作变量就等同于操作数组或集合中的元素数据

3.多维数组

（1）Java中操作多维数组的语法与一维数组类似。

（2）在实际应用中，三维以上的数组很少使用，主要使用二维数组。

（3）二维数组是一个元素为一维数组的一维数组。

（4）从语法上Java支持多维数组，但从内存分配原理的角度看，Java中只有一维数组，没有多维数组。或者说，从表面上是多维数组，实质上都是一维数组。

例：已知有3个班级各5名学员，请使用二维数组计算各个班级的总成绩

思路：

（1）根据题意先创建二维数组

（2）因为是从键盘输入数据，所以要创建键盘输入对象

（3）利用嵌套for控制班级的数量和每个班级的人数，从键盘输入每个班级学生成绩

（4）利用变量存储每个班级的总成绩，最后输出每个班级学生的总成绩

package homework;

import java.util.Scanner;

public class Xscj {

	public static void main(String[] args) {
		
		double[][]  scores = new double[3][5]; //根据题意定义数组
		
		Scanner xs = new Scanner(System.in);   //创建键盘输入对象
		double sum=0;                          //初始值
		
		for(int i=0;i<3;i++){                  //外层for循环控制班级的数量
			for(int j=0;j<5;j++){              //内层for循环控制需要输入成绩的人数

				System.out.println("请输入第"+(i+1)+"班,第"+(j+1)+"位同学考试成绩：");

				scores[i][j]= xs.nextDouble(); //由键盘输入学生成绩

				sum+=scores[i][j];             //每个班级的学生成绩进行累加
				}
			System.out.println("第"+(i+1)+"班,考试成绩总成绩："+sum);
			if(sum>0){
				sum=0;    //求出每个班级的总成绩，进行清零,方便统计下一个班级的总成绩
			}
			System.out.println("------------------------------------------------------");
		}

	}

}

例：从键盘上输入一个 3*4 的整型数组，求出其中的最大值和最小值，并显示输出

思路：

（1）根据题意先创建二维数组

（2）因为是从键盘输入数据，所以要创建键盘输入对象

（3）二维数组是分行和列，所以利用嵌套for循环结构从键盘输入二维数组元素的值

（4）利用嵌套for循环结构，遍历二维数组里的元素，把元素放在同一行转换成一维数组求最值问题

（5）假设二维数组第一个元素最大和最小，把元素存入到变量max和min 利用嵌套for循环，外层for循环控制比较轮数，内层for循环控制每一轮的比较次数，进行元素数值大小的比较

package homework;

import java.util.Scanner;

public class Subject {

	public static void main(String[] args) {
		
		//定义数组
		int[][] nums = new int[3][4];
		//创建键盘输入对象
		Scanner sc = new Scanner(System.in);
		for(int i=0;i<nums.length;i++) {             //外层for循环控制行数
			for(int j=0;j<nums[i].length;j++) {      //内层for循环控制行数
				System.out.println("请输入第"+(i+1)+"行第"+(j+1)+"列数组的值: ");
				nums[i][j]=sc.nextInt();		     //从键盘输入数值
				}
		}
		//增强for循环结构遍历二维数组
        //定义一维数组，把二维数组的元素存入一维数组
		for(int[] k :nums) {                         
			// 一维数组中每存入一个元素到变量中，变量就会立即输出这一个元素
			for(int n :k) {	
				System.out.print(n+" ");              //输出二维数组元素
			}
		}
		System.out.println();						  //换行操作
		int max = nums[0][0];                         //初始值
		int min = nums[0][0];                         //初始值
		for (int i = 0; i < nums.length; i++) {       //外层for循环控制比较的轮数
			for (int j = 0; j < nums.length; j++) {   //内层for循环控制每一轮比较的次数
				if (nums[i][j] > max) {               //元素数值大小的比较
					max = nums[i][j];			      //把最大的二维数组元素存入到变量max中
				}

				if (nums[i][j] < min) {               //元素数值大小的比较
					min = nums[i][j];			      //把最小的二维数组元素存入到变量min中
				}
			}
		}
		System.out.println("数组中的最大值是：" + max); //输出二维数组最大值
		System.out.println("数组中的最小值是：" + min); //输出二维数组最小值
	
	}		   
}