学习JavaEE的日子 day10 一维数组的深入，二维数组

已于 2024-07-01 17:26:48 修改
阅读量888 收藏 10
点赞数 18
分类专栏： 学习JavaEE 文章标签： 学习 java-ee 一维数组 二维数组 排序
于 2024-01-07 11:05:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_69595694/article/details/135437132
版权

day10

1.eclipse的使用

Eclipse是一款功能强大的集成开发环境（IDE），主要用于开发Java应用程序。

1.项目（Project）：项目是为满足特定需求而创建的代码文件集合。一个工作区可以包含多个项目，而您的代码必须归属于某个项目，不能单独存在。

2.创建Java文件：在Eclipse中创建Java文件非常简单。您可以按照以下步骤进行操作：

  • 在Eclipse的导航菜单中选择“File（文件）”>“New（新建）”>“Java Project（Java项目）”。

  • 输入项目名称并点击“Finish（完成）”。

  • 在项目上右键单击，选择“New（新建）”>“Class（类）”。

  • 输入类名和包名，并选择所需的选项。

    包名字：com.xxx.xxx

  • 点击“Finish（完成）”即可创建Java文件。

在这里插入图片描述

在这里插入图片描述

注意：补全代码：alt+/

2.一维数组的深入

2.1 数组的排序 – 冒泡排序

口诀：
N个数字来排序
两两相比小靠前
外层循环N-1
内层循环N-1-i

public static void main(String[] args) {
	
		int[] arr = {18,32,81,63,20,9};
	
		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 element : arr) {
			System.out.print(element + " ");
		}
	}

更多排序见《java十大经典排序》

2.2 数组的查找 – 线性查找

线性查找：直接遍历，找到目标值，但是效率应该是最低的那种

public static void main(String[] args) {
		
		int[] arr = {18,32,81,63,20,9};
		
		int num = 81;//需要查找的元素
		
		for (int i = 0; i < arr.length; i++) {
			if(num == arr[i]){
				System.out.println("找到该元素了，下标为：" + i);
				break;
			}
		}
		
	}

2.3 数组的查找 – 二分法查找

前提：必须先排序，再二分法查找！！！！

public static void main(String[] args) {
		
		int[] arr = {18,32,81,63,20,9};
		
		//排序 -- 9,18,20,32,63,81
		Arrays.sort(arr);
		
		int num = 81;//需要查找的元素
		
		int start = 0;
		int end = arr.length-1;
		
		while(start <= end){
			int mid = (start + end)/2;
			
			if(num > arr[mid]){
				start = mid+1;
			}else if(num < arr[mid]){
				end = mid-1;
			}else{
				System.out.println("找到该元素了，下标为：" + mid);
				break;
			}
		}

2.4 数组的复制

2.4.1 数组的复制1

复制后，改变源数组，新数组里的数据也会发生改变

浅拷贝：复制对象时，只复制对象的引用

注意：以下方法，复制后，改变源数组，新数组里的数据也会发生改变

public static void main(String[] args) {
    //源数组
	String[] names = {"麻生希","椎名空","水菜丽","朝桐光"};
	
	//新数组
	String[] newNames = names;
	
	//改变源数组的数据
	names[1] = "杨健平";
	
	//遍历新数组
	for (String element : newNames) {
		System.out.println(element);
	}
	
}

在这里插入图片描述

2.4.2 数组的复制2

深拷贝：复制对象时，把对象的属性拷贝到新的对象中

public static void main(String[] args) {
	//源数组
	String[] names = {"麻生希","椎名空","水菜丽","朝桐光"};
	
	//新数组
	String[] newNames = new String[names.length];
	
	//遍历源数组，将元素赋值给新数组
	for (int i = 0; i < names.length; i++) {
		newNames[i] = names[i];
	}
	
	//改变源数组的数据
	names[1] = "杨健平";
	
	//遍历新数组
	for (String element : newNames) {
		System.out.println(element);
	}
	
}

在这里插入图片描述

2.5 数组的扩容

需求：扩容后的长度是原来的1.5倍

public static void main(String[] args) {
    //源数组
	String[] names = {"麻生希","椎名空","水菜丽","朝桐光"};
	
	//获取数组长度
	int oldCapacity = names.length;
	//计算新的长度
	int newCapacity = oldCapacity + (oldCapacity>>1);
	
	//新数组 - [null,null,null,null,null,null]
	String[] newNames = new String[newCapacity];
	
	//遍历源数组，将数据赋值给新数组
	for (int i = 0; i < names.length; i++) {
		newNames[i] = names[i];
	}
	
	//将新数组的地址赋值给源数组
	names = newNames;
	
	//遍历源数组
	for (String element : names) {
		System.out.println(element);
	}
	
}

在这里插入图片描述

2.6 数组的删除

2.6.1 数组的删除1

数组下标从0开始，删除第二个元素

新数组长度减一，再将原数组的元素除删除元素全赋值给新数组，再将新数组的引用赋值给源数组

缺点：这种方式的删除数组，会让数组的空间越变越小。数组是用来存储数据的，越变越小会使得存储数据不方便

public static void main(String[] args) {
		
		//源数组
		String[] names = {"麻生希","椎名空","水菜丽","朝桐光"};
		
		//新数组
		String[] newNames = new String[names.length-1];
		
		//遍历源数组，将"椎名空"以外的元素赋值到新数组中
		int index = 0;
		for (String element : names) {
			if(!element.equals("椎名空")){
				newNames[index] = element;
				index++;
			}
		}
		
		//将新数组的引用赋值给源数组
		names = newNames;
		
		//遍历源数组
		for (String element : names) {
			System.out.println(element);
		}
	}

在这里插入图片描述

2.6.2 数组的删除2

数组下标从0开始，删除第二个元素，第二个元素开始，后面元素赋值给前面元素，最后一个元素赋值为null

这种方式更好

public static void main(String[] args) {
		
		//源数组
		String[] names = {"麻生希","椎名空","水菜丽","朝桐光"};
		
		//元素的迁移
		for (int i = 1; i < names.length-1; i++) {
			names[i] = names[i+1];
		}
		
		//将最后一个元素赋为null
		names[names.length-1] = null;
		
		//遍历源数组
		for (String element : names) {
			System.out.println(element);
		}
	}

在这里插入图片描述

2.7 数组作为方法的参数和返回值

需求：设计一个方法，传入int类型的数组，返回最大值和最小值

小结：

方法的返回值只能有一个

如果想返回多个数据，就可以将多个数据存入一个数组中

public static void main(String[] args) {
		
		int[] arr = {18,32,81,63,20,9};
		
		int[] maxAndMin = getMaxAndMin(arr);
		System.out.println("最大值为：" + maxAndMin[0]);
		System.out.println("最小值为：" + maxAndMin[1]);
	}
	
	public static int[] getMaxAndMin(int[] arr){
		
		int max = arr[0];
		int min = arr[0];
		
		for (int i = 1; i < arr.length; i++) {
			if(max < arr[i]){
				max = arr[i];
			}
			if(min > arr[i]){
				min = arr[i];
			}
		}
		
		return new int[]{max,min};
	}
}

小结：

方法的返回值只能有一个

如果想返回多个数据，就可以将多个数据存入一个数组中

2.8 可变参数

需求：设计一个方法，传入n个int值，获取最大值并返回

小结：

1.可变参数就是数组

2.实参就是数组里的元素

3.可变参数后不能添加其他参数

public static void main(String[] args) {
		
		int max = getMax(1,2,3,4,10,5,6,7,8,9,0);//实参作为元素压入到数组中
		System.out.println("最大值为：" + max);
	}
	
	//int... arr 就是数组
	public static int getMax(int... arr){
		int max = arr[0];
		for(int i = 1; i < arr.length; i++) {
			if(max < arr[i]){
				max = arr[i];
			}
		}
		return max;
	}
	
	//可变参数后不能添加其他参数
	public static void method(String str,int... arr){}
} //错误的

小结：

1.可变参数就是数组

2.实参就是数组里的元素

3.可变参数后不能添加其他参数

2.9 地址值

int[] arr = {1,2,3,4,5};

System.out.println(arr);//[I@6d03e736

double[] arr2 = {1.1,2.2,3.3};

System.out.println(arr2);//[D@568db2f2

打印数组的时候，实际出现的是数组的地址值。

数组的地址值：就表示数组在内存中的位置。

以[I@6d03e736为例：

6d03e736：就是数组在内存中真正的地址值。（十六进制的）

2.10 数组常见问题

空指针异常(NullPointerException)

数组越界异常(ArrayIndexOutOfBoundsException)
当访问了数组中不存在的索引，就会引发索引越界异常。
避免：
针对于任意一个数组，索引的范围：
最小索引：0
最大索引：数组的长度 - 1
数组名.length - 1

2.11 Arrays工具类

概念：Arrays是Java给我们提供的专门操作数组的工具类

理解：

1.工具类 - 该类中所有的方法都是静态的，直接使用类名调用

2.API - Java提供类的使用说明书

public static void main(String[] args) {
		
		int[] arr = {18,32,81,63,20,9};
		
		//排序 - [9, 18, 20, 32, 63, 81]
		Arrays.sort(arr);
		
		//查找(底层还用二分法去查找元素，所以必须先排序，再查找！)
		//返回值规则：如果搜索的元素包含在数组中就返回元素的下标; 否则，返回（-插入点-1）
		int index = Arrays.binarySearch(arr, 28);
		System.out.println("查找元素的下标为：" + index);
		
		//拷贝数组（目标数组，新的长度）- [9, 18, 20, 32, 63, 81, 0, 0, 0, 0]
		int[] copyOf = Arrays.copyOf(arr, 10);
		
		//拷贝区间数组（目标数组，开始下标-包含，结束下标-排他）- [18, 20, 32, 63, 81, 0, 0]
		int[] copyOfRange = Arrays.copyOfRange(copyOf, 1, 8);
		
		//替换元素 - [666, 666, 666, 666, 666, 666, 666]
		Arrays.fill(copyOfRange, 666);
		
		//替换区间元素（目标数组，开始下标-包含，结束下标-排他，替换的值） - [666, 666, 888, 888, 888, 666, 666]
		Arrays.fill(copyOfRange, 2, 5, 888);
		
		//将数组转换为字符串
		String str = Arrays.toString(copyOfRange);
		System.out.println(str);
	}

3.二维数组

理解：二维数组中包含了多个一维数组

概念：
1.数组是引用数据类型
2.数组中的元素在内存中是连续的
3.数组中的数据称之为元素
4.每个元素都有编号称之为下标
5.下标从0开始
6.数组一旦初始化成功，长度不可改变

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

数组的初始化：

静态初始化：程序员指定元素，长度由系统自动分配

动态初始化：

public static void main(String[] args) {
		
		//静态初始化一：
		//String[][] names = new String[][]{{"麻生希","椎名空","水菜丽"},{"爱田奈奈","古川伊织","水野朝阳","铃原爱蜜莉","桃谷绘里香"}};
		
		//静态初始化二：先声明，再初始化
		//String[][] names;
		//names = new String[][]{{"麻生希","椎名空","水菜丽"},{"爱田奈奈","古川伊织","水野朝阳","铃原爱蜜莉","桃谷绘里香"}};
		
		//静态初始化三：简写第一种写法
		String[][] names = {{"麻生希","椎名空","水菜丽"},{"爱田奈奈","古川伊织","水野朝阳","铃原爱蜜莉","桃谷绘里香"}};
		
		//通过下标设置元素
		names[1][2] = "巴得伟";
		
		//通过下标获取元素
		String str = names[1][2];
		System.out.println("通过下标获取元素：" + str);
		
		//获取长度
		System.out.println("获取二维数组中一维数组的个数：" + names.length);//2
		System.out.println("获取二维数组中第一个一维数组元素的个数：" + names[0].length);//3
		System.out.println("获取二维数组中第二个一维数组元素的个数：" + names[1].length);//5
		
		//遍历二维数组
		//思路：先循环获取二维数组中的一维数组，再循环获取一维数组中的元素
		
		//遍历 -- for循环
		for (int i = 0; i < names.length; i++) {
			for (int j = 0; j < names[i].length; j++) {
				System.out.println(names[i][j]);
			}
		}
		System.out.println("--------------------");
		
		//遍历 -- foreach/增强for循环
		for (String[] ss : names) {
			for (String element : ss) {
				System.out.println(element);
			}
		}
		
	}

动态初始化：程序员指定长度，由系统自动分配元素
整数类型：0
浮点类型：0.0
字符类型：’ ’
布尔类型：false
引用类型：null

public static void main(String[] args) {
		
		//动态初始化一：
		//String[][] names = new String[2][3];//2表示2个一维数组，2表示每个一维数组有3个元素
		
		//动态初始化二：先声明，再初始化
		String[][] names;
		names = new String[2][3];//2表示2个一维数组，2表示每个一维数组有3个元素
		
		//通过下标设置元素
		names[0][0] = "巴得伟1";
		names[0][1] = "巴得伟2";
		names[0][2] = "巴得伟3";
		names[1][0] = "巴得伟4";
		names[1][1] = "巴得伟5";
		names[1][2] = "巴得伟6";
		
		//通过下标获取元素
		String str = names[1][2];
		System.out.println("通过下标获取元素：" + str);
		
		//获取长度
		System.out.println("获取二维数组中一维数组的个数：" + names.length);//2
		System.out.println("获取二维数组中第一个一维数组元素的个数：" + names[0].length);//3
		System.out.println("获取二维数组中第二个一维数组元素的个数：" + names[1].length);//5
		
		//遍历二维数组
		//思路：先循环获取二维数组中的一维数组，再循环获取一维数组中的元素
		
		//遍历 -- for循环
		for (int i = 0; i < names.length; i++) {
			for (int j = 0; j < names[i].length; j++) {
				System.out.println(names[i][j]);
			}
		}
		System.out.println("--------------------");
		
		//遍历 -- foreach/增强for循环
		for (String[] ss : names) {
			for (String element : ss) {
				System.out.println(element);
			}
		}
		
	}

需求：使用动态初始化声明二维数组，其中第一个一维数组有3个元素，第二个一维数组有5个元素

public static void main(String[] args) {
		
		String[][] names = new String[2][];
		
		String[] s1 = {"麻生希","椎名空","水菜丽"};
		String[] s2 = {"爱田奈奈","古川伊织","水野朝阳","濑亚美莉","明日花绮罗"};
		
		names[0] = s1;
		names[1] = s2;
		
		for (String[] ss : names) {
			for (String element : ss) {
				System.out.println(element);
			}
		}
	}

简答题

深拷贝和浅拷贝的区别是什么?

1.浅拷贝:复制对象时，只复制对象的引用。只是增加了一个指针指向已存在的内存地址

被复制对象的所有变量都含有与原来的对象相同的值,而所有的对其他对象的引用仍然指向原来的对象.换言之,浅拷贝仅仅复制所考虑的对象,而不复制它所引用的对象.

2.深拷贝:复制对象时，把对象的属性拷贝到新的对象中。增加了一个指针并且申请了一个新的内存，使这个增加的指针指向这个新的内存， 使用深拷贝的情况下，释放内存的时候不会因为出现浅拷贝时释放同一个内存的错误。

被复制对象的所有变量都含有与原来的对象相同的值.而那些引用其他对象的变量将指向被 复制过的新对象.而不再是原有的那些被引用的对象.换言之.深拷贝把要复制的对象所引用的对象都复制了一遍.

总结

1.数组的排序和查找 – 了解

2.数组的复制、扩容、删除 – 重要

3.数组作为参数、返回值

4.可变参数 – 重要

5.Arrays工具类 – 理解工具类的概念

6.二维数组 – 注重理解

A 北枝
关注
  • 18
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
学习JavaEE的day10
02-28
在“学习JavaEE的day10”这个主题中，我们主要关注的是如何使用Eclipse集成开发环境进行JavaEE项目的开发。Eclipse是一款广泛使用的开源IDE，尤其在Java开发者中非常流行，它为编写、调试和部署Java应用程序提供了...
javaSE基础，进制+二维数组
08-24
1 debug代码调试 必须掌握 2 了解进制 3 了解十进制到任意进制的转换 4 了解任意进制到十进制的转换 5 掌握二维数组的基本使用
学习JavaEE的日子 day09 一维数组
weixin_69595694的博客
01-05 545
一维数组概念数组的声明数组的初始化：静态初始化、动态初始化。
《JavaEE》第三周day1学习笔记-数组、二维数组、异常
Yan的博客
12-07 156
数组 数组查找 常用的两种查找方式 顺序查找 二分查找 顺序查找 概念：通过数组下标提取元素，与目标进行对比，如果找到匹配元素则返回下标；如果未找到则返回特定值（通常为-1）。 备注：通过循环实现。 public static int orderSearch(int[] array, int target) { for (int i = 0; i < array...
javaEE_day04☞java数组学习整理
sinat_40482939的博客
07-20 133
理解数组 数组也是一种数据类型， 它本身是一种引用类型。 1.什么是数组：存储相同数据类型的容器 2.特点： Java 的数组既可以存储基本类型的数据 ，也可以存储引用类型的数据，只要所有的数组元素具有相同的类型即可； 有序的（下标，从0开始）； 一旦数组的初始化完成，数组在内存中所占的空间将被固定下来，因此数组的长度将不可改变。 （属性 length）即使把某个数组元素的数据清空 ，但它所占的空间依然被保留 ，依然属于该数组，数组的长度依然不变。 定义数组 数据元素的类型[] 数组名； int[] n
JavaEE Day11 二维数组
yjp1240201821的博客
03-09 732
本节主要讲解Java的二维数组、数组作为方法的参数和返回值、可变参数以及Arrays工具类，附带二维数组的理解图与其经典例子帮助深刻理解。
java二维数组遍历后转为一维数组_java基础学习笔记-day06-(2020/07/02-现在）
weixin_39677106的博客
11-21 108
本文结构：java知识图谱概述java基础程序设计及语法java面向对象编程项目家庭记账软件The Java™ Tutorials​docs.oracle.comjava知识图谱概述java三个版本分类：javase ：开发桌面级应用，有一部分是Java基础，是学习javaee的前提javaee ：web后台、企业级应用javame ：移动终端应用JDK、JRE、JVM的关系JDK=JRE+jav...
学习JavaEE的日子 Day32 线程池
weixin_69595694的博客
03-28 1368
1.Java自带的线程池单个线程的线程池指定线程个数的线程池可缓存的线程池延迟任务的线程池2.线程池的7大参数核心线程数最大线程数任务队列（有界、无界、同步、优先队列）拒绝策略闲置时间时间单位线程工厂3.线程池的调用步骤（核心线程、任务队列、普通线程、拒绝策略）4.任务队列及底层原理（有界、无界、同步、优先队列）
学习JavaEE的日子 Day27 手撕HashMap底层原理
weixin_69595694的博客
03-17 1402
1.手撕HashMap底层原理shCode() + 位运算​ JDK1.8 – 将key的hash值(int-32)分为高16位和低16位，两者进行异或的位运算，比之前更简洁区别2 - 插入链表的法则：​ JDK1.7 – 头插法​ JDK1.8 – 尾插法区别3 - 数据结构：​ JDK1.7 – 一维数组 + 单向链表​ JDK1.8 – 一维数组 + 单向链表 + 红黑树（目的：加上红黑树提高查询效率）JDK1.8版本的HashMap数据结构是如何切换的？
【济南中心】JavaEE基础班新课程day04：随机数和数组
伟大的程序员
02-14 165
举个例子，如果我要产生一个0-100的随机数怎么写代码呢？                      [Java] 纯文本查看 复制代码?1 2 3 4 5 6 [/size][size=3] –      导包 •       import java.util.Random; –      创建对象 •       Random r = new Random(); –...
学习JavaEE的day01
02-28
总的来说，“学习JavaEE的day01”标志着一个全面深入JavaEE开发的起点，通过逐步学习和实践，你将逐渐熟悉这个强大的企业级开发平台，并能构建出高效、稳定的Web应用。记得在学习过程中结合文档、代码示例和图形化...
学习JavaEE的day02
02-28
在“学习JavaEE的day02”这个主题中，我们主要关注的是JavaEE技术的学习过程，这通常包括了Web开发的基础、服务器配置、框架应用等多个方面。在这个阶段，开发者可能会遇到许多关键知识点，例如环境搭建、开发工具的...
学习JavaEE的day21
03-05
在“学习JavaEE的day21”这个主题中，我们主要关注的是Java企业版（Java Enterprise Edition，简称JavaEE）的深入学习。JavaEE是一种用于构建企业级分布式应用程序的平台，它提供了丰富的组件和服务，包括但不限于...
昇思25天学习打卡营第14天|LLM-文本解码原理--以MindNLP为例
wwt72的博客
07-17 841
限制输出序列的最大长度为50个token。top-p=0.95，top-p采样表示在每一步生成token时，只从概率分布中累计概率达到95%的token中进行采样，有助于保持生成文本的流畅性和质量，同时允许一些低概率的token被选中，从而增加多样性。表示禁用了top-k采样，因为在top-k采样中，通常是从概率最高的k个token中随机选择一个token作为下一个输出，而这里设置为0表示不限制token的选择，实际上这将等同于使用 softmax 概率分布直接进行采样。这有助于提高生成文本的多样性。
kubernetes学习日志（七）
qq_47037022的博客
07-18 591
本文记录了service管理，ingress管理，Dashboard管理插件，集群鉴权策略，角色与全局角色，赋权与全局角色赋权。
昇思25天学习打卡营第16天|munger85
MungerVC
07-20 375
MobileNet网络是由Google团队于2017年提出的专注于移动端、嵌入式或IoT设备的轻量级CNN网络，相比于传统的卷积神经网络首先安装依赖下载数据。
从0开始的STM32HAL库学习6
最新发布
hwq_1229_0525的博客
07-21 211
配置红色框图中的各种配置时钟源选择外部时钟 21.预分频器Prescaler，下面填0，不分频2.计数模式，计数模式选择为向上计数3.自动重装寄存器，自动重装计数器填为10，计数到10后清空并出发中断4.滤波器的频率分频：不使用影子寄存器。
huawei USG6001v1学习--防火墙相关知识（1）
m0_65350813的博客
07-19 399
防火墙主要是借助硬件和软件的作用于内部和外部网络的环境间产生一种保护的屏障，从而实现对计算机不安全网络因素的阻断。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

A 北枝

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值