数组的使用

最新推荐文章于 2023-07-19 19:59:41 发布
最新推荐文章于 2023-07-19 19:59:41 发布
阅读量194 收藏
点赞数
文章标签： java 开发语言 排序算法 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_59195172/article/details/122387849
版权

目录

1.1、一维数组

数组的声明

数组的调用

获取数组的长度

遍历数组

数组的默认初始化值

1.2、二维数组

数组的声明

数组的调用

数组的长度

遍历数组

默认初始化

1.3、对数组的常见算法

数组的基本操作

数组的复制，反转，查找

 线性查找

二分法查找 

数组的排序

冒泡排序

 快速排序

各排序算法的性能 ​

 1.4、Arrays 工具类的使用

1.5、常见bug

1.数组角标越界的异常:ArrayIndexOutOfBoundsException

2.空指针异常:NullPointerException  

1.1、一维数组

数组的声明

      静态初始化:数组的初始化和数组元素的赋值操作同时进行
        int[] ids = new int[]{1001,1002,1003,1004};

       或可简化为int[]={1001,1002,1003};   
      动态初始化:数组的初始化和数组元素的赋值操作分开进行
        String[] names = new String[5]; 

数组的调用

    //数组的角标(或索引)从0开始的，到数组的长度-1结束
        names[0] = "张郃";
        names[1] = "王陵";
        names[2] = "张学良";
        names[3] = "王传志";    //charAt(0)
        names[4] = "李峰";
//        names[5] = "周礼";    //如果数组超过角标会通过编译，运行失败。

获取数组的长度

//属性：length

System.out.println(names.length);

System.out.println(ids.length); 

遍历数组

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

数组的默认初始化值

* > 数组元素是整形：0 

> 数组元素是浮点型：0.0  

> 数组元素是char型：0或'\u0000'，而非'0'  

> 数组元素是boolean型:false

> 数组元素是引用数据类型：null

/*
 * 2. 从键盘读入学生成绩，找出最高分，并输出学生成绩等级。
 * 成绩>=最高分-10    等级为’A’   
 * 成绩>=最高分-20    等级为’B’
 * 成绩>=最高分-30    等级为’C’   
 * 其余等级为’D’
 * 提示：先读入学生人数，根据人数创建int数组，存放学生成绩。
 */
import java.util.Scanner;
public class ArrayDemo2 {
	public static void main(String[] args) {
		//1.使用Scanner，读取学生的个数
		Scanner scan = new Scanner(System.in);
		System.out.print("请输入学生人数：");
		int num = scan.nextInt();
		
		//2.创建数组，存储学生成绩，动态初始化
		int[] str = new int[num];
		System.out.println("请输入" + num + "个学生成绩");
				
		//3.给数组中的元素赋值
		int maxnum = 0;
		for(int i = 0;i < str.length;i++){
			str[i] = scan.nextInt();
			//4.获取数组元素中的最大值：最高分
			if(maxnum < str[i]){
				maxnum = str[i];
			}
		}
		
		//5.根据每个学生成绩与最高分的差值，得到每个学生的等级，并输出等级和成绩	
		char Grade;	//成绩等级
		for(int i = 0;i < str.length;i++){
			if(maxnum - str[i] <= 10){
				Grade = 'A';
			}else if(maxnum - str[i] <= 20){
				Grade = 'B';
			}else if(maxnum - str[i] <= 30){
				Grade = 'C';
			}else{
				Grade = 'D';
			}
			
			System.out.println("student " + i + "score is" + str[i] + 
					" grade is " + Grade);
		}
	}
}

1.2、二维数组

数组的声明


        //静态初始化
        int[][] arr1 = new int[][]{{1,2,3},{4,5,6},{7,8,9}};

        或int[][] arr1 = {{1,2,3},{4,5,6},{7,8,9}};
        //动态初始化1
        String[][] arr2 = new String[3][2];
        //动态初始化2
        String[][] arr3 = new String[3][];

数组的调用

System.out.println(arr1[0][1]); 

System.out.println(arr2[1][1]); 

数组的长度

System.out.println(arr4.length); //3

System.out.println(arr4[0].length); //3

System.out.println(arr4[1].length); //4

遍历数组

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

默认初始化

规定：二维数组分为外层数组的元素，内层数组的元素
 *     int[][] arr = new int[4][3]; 
 *  外层元素:arr[0],arr[1]等
 *  内层元素:arr[0][0],arr[1][2]等
 *  
 *数组元素的默认初始化值
 *     针对于初始化方式一：比如：int[][] arr = new int[4][3];
 *         外层元素的初始化值为：地址值
 *         内层元素的初始化值为：与一维数组初始化情况相同
 *     
 * 针对于初始化方式而：比如：int[][] arr = new int[4][];
 *         外层元素的初始化值为：null
 *         内层元素的初始化值为：不能调用，否则报错。

1.3、对数组的常见算法

数组的基本操作

算法的考察：求数值型数组中元素的最大值、最小值、平均数、总和等

/*
 * 算法的考察：求数值型数组中元素的最大值、最小值、平均数、总和等
 * 
 * 定义一个 int 型的一维数组，包含 10 个元素，分别赋一些随机整数，
 * 然后求出所有元素的最大值，最小值，和值，平均值，并输出出来。
 * 要求：所有随机数都是两位数。
 * 
 * [10,99]
 * 公式：(int)(Math.random() * (99 - 10 + 1) + 10)
 */
public class ArrayTest1 {
	public static void main(String[] args) {
		int[] arr = new int[10];
		//数组赋值
		for(int i = 0;i <arr.length;i++){
			arr[i] = (int)(Math.random() * (99 - 10 + 1) + 10);
		}
		
		//遍历
		for(int i =0;i < arr.length;i++){
			System.out.print(arr[i] + " ");
		}
		System.out.println();
		
		//求数组元素的最大值
		int maxValue = arr[0];
		for(int i = 1;i <arr.length;i++){
			if(maxValue < arr[i]){
				maxValue = arr[i];
			}
		}
		System.out.println("最大值：" + maxValue);
		
		//求数组元素的最小值
		int minValue = arr[0];
		for(int i = 1;i <arr.length;i++){
			if(minValue > arr[i]){
				minValue = arr[i];
			}
		}
		System.out.println("最小值：" + minValue);
		
		//求数组元素的总和
		int sum = 0;
		for(int i = 1;i <arr.length;i++){
			sum += arr[i];
		}
		System.out.println("总和：" + sum);
		
		//求数组元素的平均数
		double avgVales = sum / arr.length;
		System.out.println("平均数：" + avgVales);		
	}
}

数组的复制，反转，查找

小贴士：arr2=arr1;不能称为数组的复制，本质上是将arr1的地址赋值给arr2，对arr2进行修改依然能对arr1产生影响

public class ArrayTest3 {
	public static void main(String[] args) {
	
		String[] arr = new String[]{"SS","QQ","YY","XX","TT","KK","EE","GG"};
		
		//数组的复制
		String[] arr1 = new String[arr.length];
		for(int i = 0;i < arr1.length;i++){
			arr1[i] = arr[i];
		}
		
		//数组的反转
		//方法一：
//		for(int i = 0;i < arr.length / 2;i++){
//			String temp = arr[i];
//			arr[i] = arr[arr.length - i - 1];
//			arr[arr.length - i - 1] = temp;
//		}
		
		//方法二：
		for(int i = 0,j = arr.length - 1;i < j;i++,j--){
			String temp = arr[i];
			arr[i] = arr[j];
			arr[j] = temp;
		}
		
		//遍历
		for(int i = 0;i < arr.length;i++){
			System.out.print(arr[i] + "\t");
		}
		System.out.println();	
		
	}
}

 线性查找

//查找（或搜索）
		//线性查找
		String dest = "BB";	//要查找的元素
		dest = "CC";
		
		boolean isFlag = true;
		
		for(int i = 0;i < arr.length;i++){
			if(dest.equals(arr[i])){
				System.out.println("找到了指定元素，位置为：" + i);
				isFlag = false;
				break;
			}
		}
		if(isFlag){
			System.out.println("很遗憾，没找到！");
		}

二分法查找 

//二分法查找：
		//前提：所要查找的数组必须有序
		int[] arr2 = new int[]{-98,-34,2,34,54,66,79,105,210,333};
		
		int dest1 = -34;
		int head = 0;	//初始的首索引
		int end = arr2.length - 1;	//初始的末索引
		boolean isFlag1 = true;
		while(head <= end){
			int middle = (head + end)/2;
			
			if(dest1 == arr2[middle]){
				System.out.println("找到了指定元素，位置为：" + middle);
				isFlag1 = false;
				break;
			}else if(arr2[middle] > dest1){
				end = middle - 1;
			}else{	//arr2[middle] < dest1
				head = middle + 1;
			}	
		}
		
		if(isFlag1){
			System.out.println("很遗憾，没找到！");
		}

数组的排序

冒泡排序

/*
 * 数组的冒泡排序的实现
 * 
 */
public class BubbleSortTest {
	public static void main(String[] args) {
		
		int[] arr = new int[]{43,32,76,92,-65,85,71,-42};
		
		//冒泡排序
		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");
		}
	}
}

 快速排序

/**
  * 快速排序
  * 通过一趟排序将待排序记录分割成独立的两部分，其中一部分记录的关键字均比另一部分关键字小，
  * 则分别对这两部分继续进行排序，直到整个序列有序。
  *
 */
public class QuickSort {
	private static void swap(int[] data, int i, int j) {
		int temp = data[i];
		data[i] = data[j];
		data[j] = temp;
	}
	private static void subSort(int[] data, int start, int end) {
		if (start < end) {
			int base = data[start];
			int low = start;
			int high = end + 1;
			while (true) {
				while (low < end && data[++low] - base <= 0)
					;
				while (high > start && data[--high] - base >= 0)
					;
				if (low < high) {
					swap(data, low, high);
				} else {
					break;
				}
			}
			swap(data, start, high);
			
			subSort(data, start, high - 1);//递归调用
			subSort(data, high + 1, end);
		}
	}
	public static void quickSort(int[] data){
		subSort(data,0,data.length-1);
	}
	
	public static void main(String[] args) {
		int[] data = { 9, -16, 30, 23, -30, -49, 25, 21, 30 };
		System.out.println("排序之前：\n" + java.util.Arrays.toString(data));
		quickSort(data);
		System.out.println("排序之后：\n" + java.util.Arrays.toString(data));
	}
}

各排序算法的性能 

 1.4、Arrays 工具类的使用

java.util.Arrays类即为操作数组的工具类，包含了用来操作数组（比如排序和搜索）的各种方法。

1.5、常见bug

1.数组角标越界的异常:ArrayIndexOutOfBoundsException

//1.数组角标越界的异常:ArrayIndexOutOfBoundsException
        int[] arr = new int[]{1,2,3,4,5,6};
        
        //错误1：
//        for(int i = 0;i <= arr.length;i++){
//            System.out.println(arr[i]);
//        }
        
        //错误2：
//        System.out.println(arr[-2]);
        

2.空指针异常:NullPointerException
  

      //情况一:
//        int[] arr2= new int[]{1,2,3};
//        arr2 = null;
//        System.out.println(arr2[0]);
        //情况二:
//        int[][] arr2 = new int[4][];
//        System.out.println(arr2[0][0]);
        
        //情况三:
//        String[] arr3 = new String[]{"AA","QQ","YY","XX","TT","KK"};
//        arr3[0] = null;
//        System.out.println(arr3[0].toString());      

一堆乱码的Java
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
php数组使用规则分析
10-24
主要介绍了php数组使用规则,实例分析了php中数组的用法,具有一定参考借鉴价值,需要的朋友可以参考下
Java基础（数组）
最新发布
2301_77599154的博客
07-30 216
数组是具有相同数据类型的一组数据的集合，例如球类的集合，足球，篮球，羽毛球等电器的集合，电视机，洗衣机，电风扇等。在程序设计中可以将这些集合称为数组。数组中的每个元素具有相同的数据类型。在JAVA中同样将数组看做一个对象，虽然基本数据类型不是对象，但由基本数据类型组成的数组却是对象。
Java入门篇--数组（一）
luoyuhhh的博客
11-11 458
Java数组基础知识
Java基础--------数组
詹煜彪9527
02-04 1万+
一 . 数组的概念 数组，可以看成是多个相同类型数据的组合，对这些数据的统一管理。 数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。 数组的元素可以是任何数据类型，包括基本类型和引用类型。 C和C++中...
Java数组，超详细整理，适合新手入门
久绊A的博客
02-21 2610
Java数组，超详细整理，适合新手入门、什么是Java中的数组？、数组有哪些常见的操作？、数组的五种赋值方法和使用方法声明数组、声明数组并且分配空间、声明数组同时赋值(1)声明数组同时赋值(2)从控制台输入向数组赋值、求总和平均、求数组中最大值最小值、对数组进行升序排序、不调用方法进行数组排序、Arrays 类常用方法
JAVA基础 —— 数组
hdakj22的博客
02-11 962
数组 ； 数组静态初始化和动态初始化 ；数组的地址值和元素访问 ； 数组遍历
NumPy 数组使用大全
09-19
主要介绍了NumPy 数组使用大全，在本教程中，你将学习如何在 NumPy 数组上以多种方式添加、删除、排序和操作元素。文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面...
Mootools 1.2教程(3) 数组使用简介
09-05
在上一篇教程——《Mootools 1.2教程(2)——DOM选择器》中，我们介绍了一下选择器，其中有很多方法就会返回数组（一个你可以对其中内容进行多种操作的特殊列表）。
php 数组使用详解 推荐
01-20
PHP的数组函数众多，下面是我学习的小结，借此记之，便于以后鉴之…… 一、数组定义： 数组的定义使用 array（）方式定义，可以定义空数组： .foreach遍历： 复制代码 代码如下: <?php $number = array(1,3,5,7,9...
Java基础—数组
qq_48384411的博客
04-27 143
数组（array）是一种最简单的复合数据类型，它是有序数据的集合，数组中的每个元素具有相同的数据类型，可以用一个统一的数组名和不同的下标来确定数组中唯一的元素。根据数组的维度，可以将其分为一维数组、二维数组和多维数组等。
Java基础入门——数组
_山月见光的博客
07-19 183
在内存开辟一块空间。也是变量，在内存中开辟一串连续的空间。数组长度一旦确定，就不能修改。
Java基础--数组
weixin_65081564的博客
07-19 93
数组的常见概念。
Java数组常用操作
qq_57066758的博客
02-13 687
java数组常用操作
Java基础数组
youngbird1998的博客
04-13 967
数组(array)是一种用于存储多个相同类型数据的存储模型 数组的定义格式分别为： java中的数组需要先初始化，然后才能使用 初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值 动态初始化： 动态初始化：初始化时只指定数组长度，由系统为数组分配初始值 例子：int [ ] arr = new int[3]; 数据元素访问： 数组内部保存的数据的访问方式 格式：数组名[索引] 索引是数组中数据的编号方式作用： 索引用于访问数...
Educoder题目：Java入门 - 数组基础答案解析
bingeho的博客
11-01 3545
初识数组 chapter7/src/step1/HelloWorld.java package step1; public class HelloWorld { public static void main(String[] args) { /********** Begin **********/ int[] array = {91,88,60}; System.out.println("数组的第一个值为：" + array[0] ); //在这里输出数
初识数组(java)
m0_74824619的博客
03-26 222
数组（Array）是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。
Java基础知识——数组
qq_65573436的博客
08-04 619
1、一维数组 2、二维数组 3、数组排序
JAVA头哥作业07 Java入门 - 数组基础
nianci602的博客
03-31 3545
处补充代码，计算并输出数组的平均值和最大值。数组初始化有错误的是（ABCD）那么该数组一共有（C ）个元素。区域中定义如下二维数组，使用。以下数组声明有误的是（C）以下的程序是否有错（B）程序运行的结果为（D）根据提示，在右侧编辑器。第3关：选择题（1）第6关：选择题（2）
Java基础篇：数组
热门推荐
张维鹏的博客
10-10 3万+
数组是一种线性数据结构，是一个使用连续的内存空间存放相同的数据类型的集合容器，与其他容器相比，数组的区别主要在于性能与保存基本类型的能力。 在Java中，数组是一种效率最高的存储和随机访问对象的方式，通过寻址公式，随机访问的时间复杂可以达到O(1)，但是为了保持空间的连续性，在数组中插入、删除数据时，都需要移动后面数据，该操作的时间复杂度为O(n)。另外，由于空间上连续，所以数组对CPU缓存比较友好，借助CPU的缓存机制，预读数组中的数据，提高访问效率。但是，由于数组是定长
postgres 数组使用场景
06-11
以下是一些常见的数组使用场景： 1. 存储多个值：例如，一个产品可能有多种颜色或尺寸，可以使用数组将这些值存储在单个字段中。 2. 快速查询和过滤：使用数组可以更轻松地查询和过滤包含特定值的记录，而不需要...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值