eclipse的安装与使用、一维数组（排序，查找，复制，扩容，删除 ）、数组作为参数，返回值、可变参数、Arrays工具类、二维数组、五子棋--学习JavaEE的day10

已于 2024-02-29 16:31:39 修改
阅读量561 收藏 11
点赞数 10
文章标签： eclipse 学习 java-ee 开发语言
于 2024-02-28 18:51:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gangain/article/details/136348529
版权

day10

一、eclipse的使用

eclipse理解图
eclipse理解图

安装包见资源

二、数组的排序和查找

数组的排序

冒泡排序

口诀：

N个数字来排序

两两相比小靠前

外层循环N-1

内层循环N-1-i

	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 + " ");
	}

数组的查找

1.线性查找
	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. 二分法查找

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

	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;
		}
	}

三、数组的复制、扩容、删除

数组的复制

1.数组的复制1

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

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

数组的复制1

	//源数组
	String[] names = {"麻生希","椎名空","水菜丽","朝桐光"};
	
	//新数组(源数组的地址赋值给新数组)
	String[] newNames = names;
	
	//改变源数组的数据
	names[1] = "奇男子";
	
	//遍历新数组
	for (String element : newNames) {
		System.out.println(element);
	}
2.数组的复制2

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

数组的复制2

	//源数组
	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);
	}

数组的扩容

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

用位运算效率更高

数组的扩容

	//源数组
	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);
	}

数组的删除

1.数组的删除1

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

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

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

数组的删除1

	//源数组
	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.数组的删除2

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

这种方式更好
数组的删除2

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

四、数组作为参数、返回值

需求：设计一个方法，传入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};
}

五、可变参数

需求：设计一个方法，传入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){}

六、Arrays工具类

概念：

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

理解：

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

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

	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);

七、二维数组

理解：

二维数组中包含了多个一维数组

概念：

1.数组是引用数据类型

2.数组中的元素在内存中是连续的

3.数组中的数据称之为元素

4.每个元素都有编号称之为下标

5.下标从0开始

6.数组一旦初始化成功，长度不可改变

数组的声明：

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

数组的初始化：

1.静态初始化：

程序员指定元素，长度由系统自动分配

二维数组静态初始化内存图二维数组静态初始化内存图

	//静态初始化一：
	//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);
		}
	}
2.动态初始化：

程序员指定长度，由系统自动分配元素

数据类型默认值：

​ 整数类型：0

​ 浮点类型：0.0

​ 字符类型：’ ’

​ 布尔类型：false

​ 引用类型：null

二维数组动态初始化内存图
二维数组动态初始化内存图

	//动态初始化一：
	//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个元素

	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);
		}
	}

八、五子棋

基本代码

import java.util.Scanner;

public class Test01 {
	public static void main(String[] args) {
		
	//棋盘长度
	int len = 20;
	//棋盘容器
	String[][] gobang = new String[len][len];
	//棋盘的符号
	String add = "╋";//┼
	String black = "●";
	String white = "○";
	String[] indexs = {"⒈","⒉","⒊","⒋","⒌","⒍","⒎","⒏","⒐","⒑","⒒","⒓","⒔","⒕","⒖","⒗","⒘","⒙","⒚","⒛"};
	
	//初始化棋盘
	for (int i = 0; i < gobang.length; i++) {//i控制行
		for (int j = 0; j < gobang[i].length; j++) {//j控制列
			
			if(j == len-1){//每行的最后一列 -- 设置xx行
				gobang[i][j] = indexs[i];
						
			}else if(i == len-1){//最后一行 -- 设置xx列
				gobang[i][j] = indexs[j];
				
			}else{
				gobang[i][j] = add;
			}
		}
	}
	
	//打印棋盘
	for (String[] ss : gobang) {
		for (String element : ss) {
			System.out.print(element);
		}
		System.out.println();
	}
	
	Scanner scan = new Scanner(System.in);
	boolean bool = true;//true-黑子 false-白字
	
	boolean flag = true;
	while(flag){

		System.out.println("请" + ((bool)?"黑":"白") + "子输入坐标：");
		int x = scan.nextInt()-1;
		int y = scan.nextInt()-1;
		
		//判断坐标是否超出棋盘范围
		if(x<0 || x>len-2 || y<0 || y>len-2){
			System.out.println("落子失败 - 坐标超出棋盘范围");
			continue;
		}
		
		//判断坐标上是否有棋子
		if(!gobang[x][y].equals(add)){
			System.out.println("落子失败 - 坐标上已有棋子");
			continue;
		}
		
		//落子
		gobang[x][y] = (bool)?black:white;
		
		//打印棋盘
		for (String[] ss : gobang) {
			for (String element : ss) {
				System.out.print(element);
			}
			System.out.println();
		}
		
		//棋子置反
		bool = !bool;
		
		//提升作业：判断输赢	

	}
	
	//关闭资源
	scan.close();
	
}

}

提升作业：判断输赢

见文件代码Gobang01
参考思路：
判断输赢就是判断左斜、右斜、横向、竖直四个方向满五个棋子连在一起

当然还有特殊下满棋盘平局暂时不考虑

总结：

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

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

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

4.可变参数 – 重要

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

6.二维数组 – 注重理解

7.五子棋

程序奇男子
关注
  • 10
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
计算机后端-Java-Java核心基础-第07章 Eclipse的使用与数组 14. 一维数组的课后练习1.avi
05-22
计算机后端-Java-Java核心基础-第07章 Eclipse的使用与数组 14. 一维数组的课后练习1.avi
学习JavaEE的日子 day10 一维数组的深入，二维数组
weixin_69595694的博客
01-07 862
1.数组的排序和查找 -- 了解 2.数组的复制、扩容、删除 -- 重要 3.数组作为参数、返回值 4.可变参数 -- 重要 5.Arrays工具类 -- 理解工具类的概念 6.二维数组 -- 注重理解
Day009---java中的一维数组和二维数组
码到成龚的博客
04-10 1601
一维数组的声明，创建，应用操作，及一维数组的冒泡排序。 二维数组的声明，创建
java二维数组元素的引用,Java一一Arrays工具类与二维数组
weixin_39862669的博客
03-21 315
Arrays工具类使用帮助文档:1.61.8作用：主要用于对数组进行排序，查找，填充，比较等的操作Arrays工具类存在于java.util包下，所以使用的第一步就是导包：import java.util.Arrays;注意1：如果在同一个Java文件中同时使用Scanner和Arrays，则可以向如下方式导包：import java.util.Scanner;import java.util.A...
Java基础——Arrays工具类、二维数组
冷漠的小猿
08-09 1330
Arrays工具类、二维数组 1.Arrays工具类 2.方法传参和返回值 3.可变参数 4.二维数组 1.1 二维数组的概念 1.2 二维数组的定义 1.3 数组的初始化 1.4 二维数组的访问 5.调试和文档注释 第一节 Arrays工具类 使用帮助文档: 1.6 1.8 作用：主要用于对数组进行排序，查找，填充，比较等的操作 Arrays工具类存在于java.ut...
java第二天：Eclipse使用、数组、面向对象
m0_61927991的博客
09-05 501
java
七、二维数组
qq_53394650的博客
07-28 267
1.1.3Arrays工具类 Arrays:此类包含用来操作数组（比如排序和搜索)的各种方法 Arrays工具类存在于java.util包下，所以使用的第一步就是导包: import java.util.Arrays; 注意1:如果在同一个Java文件中同时使用Scanner和Arrays，则可以向如下方式导包: 注意2:但凡是工具类，类中的方法全部是静态的，方便调用调用语法:类名.方法名（实参列表) 1.1.4.3基本数据类型作为返回值 示例:编写一个方法，实现1-100和，并返回结果 .
Arrays工具类、二维数组
hougelaihuihui的博客
07-28 172
一、Arrays工具类 Arrays：此类包含用来操作数组（比如排序和搜索）的各种方法 Arrays工具类存在于java.util包下，所以使用的第一步就是导包：import java.util.Arrays; 注意：但凡是工具类，类中的方法全部是静态的，方便调用 调用语法：类名.方法名（实参列表） 代码： //演示Arrays工具类的使用 import java.util.Arrays; public class Demo1 { public static void main...
Java一一Arrays工具类与二维数组
weixin_45504233的博客
08-19 525
Arrays工具类 使用帮助文档: 1.6 1.8 作用：主要用于对数组进行排序，查找，填充，比较等的操作 Arrays工具类存在于java.util包下，所以使用的第一步就是导包：import java.util.Arrays; 注意1：如果在同一个Java文件中同时使用Scanner和Arrays，则可以向如下方式导包： import java.util.Scanner; ...
gnu c语言可变参数,GNU C和C99标准中的可变参数宏(variadic macros)
weixin_39569753的博客
05-18 241
用可变参数宏(variadic macros)传递可变参数表你可能很熟悉在函数中使用可变参数表，如：void printf(const char* format, …);直到最近，可变参数表还是只能应用在真正的函数中，不能使用在宏中。C99编译器标准终于改变了这种局面，它允许你可以定义可变参数宏(variadic macros)，这样你就可以使用拥有可以变化的参数表的宏。可变参数宏就像下面这个样子...
计算机后端-Java-Java核心基础-第07章 Eclipse的使用与数组 17. 二维数组元素的调用.avi
05-22
计算机后端-Java-Java核心基础-第07章 Eclipse的使用与数组 17. 二维数组元素的调用.avi
计算机后端-Java-Java核心基础-第07章 Eclipse的使用与数组 18. 二维数组的长度和遍历.avi
05-22
计算机后端-Java-Java核心基础-第07章 Eclipse的使用与数组 18. 二维数组的长度和遍历.avi
14_Java面向对象_第6天（Eclipse高级、类与接口作为参数返回值）_讲义
02-16
14_Java面向对象_第6天（Eclipse高级、类与接口作为参数返回值）_讲义
学Java的第十四天–数组&eclipse使用
12-21
Eclipse 开创性地集成 Neon Stack，将 EVM 兼容性带到 SVM 网络
最新发布
Black_mario的博客
05-03 932
Neon Stack 与 Eclipse 之间的合作，以其独特的设计，将引导开发者构建高质量的 dApp，这些 dApp 能够利用两个主要的 L1—— Ethereum 和 Solana ——及其原生生态系统和虚拟机所能提供的最佳特性。通过此次合作，双方都预见到一个具有无与伦比的吞吐性和可扩展性的未来。2024年5月2日，全球——在塑造区块链网络的战略联盟的过程中，Eclipse 通过集成 Neon EVM 核心团队开发的技术堆栈 Neon Stack，成为首个打破 EVM-SVM 兼容性障碍的生态。
JAVA 学习·泛型（二）——通配泛型
wr114514的博客
05-02 1073
介绍了Java泛型中的重要知识点——通配泛型及其应用。
限流的学习
weixin_43675252的博客
05-01 465
限流算法：滑动窗口算法滑动日志算法漏桶算法令牌桶算法。
如何用C#语言定义一个三维数组来动态接收数据库表中的坐标信息
02-21
用C编程的方法有很多，但最常见的方法是使用C语言的编程环境，如Visual Studio，Eclipse，CodeBlocks等。另外，你还可以使用文本编辑器（如Sublime Text，Notepad ++）来编写C代码，然后使用编译器（如GCC，Clang）...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值