Java基础——数组与方法

最新推荐文章于 2023-04-11 20:27:24 发布
最新推荐文章于 2023-04-11 20:27:24 发布
阅读量350 收藏 2
点赞数 1
分类专栏： Java基础 JAVA学习 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47208494/article/details/124003506
版权

一、数组与方法

1、数组作为返回值

作用：解决了方法只能返回一个值的问题
语法：
	定义：
		public static 返回值类型 方法名(形参列表){
			方法体
			return 返回值;
		}
		注意：return表示结束方法。
	调用：
		方法名(实参列表);

2、数组作为参数

作用：解决方法形参长度不定的问题，但是形参的数据类型要一致。
语法：
	定义：
		public static 返回值类型 方法名(形参列表){
			方法体
			return 返回值;
		}
		注意：return表示结束方法。
	调用：
		方法名(形参列表);

案列：
	计算用户超市购物金额
public class Demo03 {
	public static void main(String[] args) {
		//定义数组num01
		double[] num01 = {20.3,54.2,89.6,46,27,16.8};
		double money = getMoney(num01);
		System.out.println("数组num01的和为：" + money);
		
		//定义数组num02
		double[] num02 = {15.6,15,14,9.9,45,23.3,2};
		System.out.println("数组num01的和为：" + getMoney(num02));
	}

	//计算数组值的和
	private static double getMoney(double[] rmb) {
		//定义一个变量记录总价
		double sum = 0;
		//遍历数组将数组中的元素与原总价相加,赋值给总价
		for (double num : rmb) {
			sum += num;
		}
		//返回总价
		return sum;
	}
}

运行结果：
在这里插入图片描述

二、可变参数

作用：就是简化数组作为参数
语法：
	数据类型...变量名
注意：
	1、可变参数必须在定义方法时形参末尾定义
	2、一个方法中不能拥有多个可变参数
	3、只能在方法的形象中定义

三、算法

两数交换

public class Demo04 {
	public static void main(String[] args) {
		/**
		 * 交换两个数
		 */
		int A = 5;
		int B = 8;
		
		//方案一
		int C = A;
		A = B;
		B = C;
		System.out.println("方案一、A等于："+A);
		System.out.println("方案一、B等于："+B);
		
		//方案二
		int D = 20;
		int E = 15;
		
		D = D + E;
		E = D - E;  // D + E - E
		D = D - E;  // D + E - D - E + E
		System.out.println("方案二、D等于："+D);
		System.out.println("方案二、E等于："+E);
		
		//方案三
		int F = 22;
		int G = 11;
		 
		F = F ^ G;
		G = F ^ G;
		F = F ^ G;
		System.out.println("方案三、F等于："+F);
		System.out.println("方案三、G等于："+G);
	}
}

运行结果
在这里插入图片描述

将最大值移动至数组尾部

public class Demo05 {
	public static void main(String[] args) {
		/**
		 * @author 豆三岁
		 * 寻找数组中最大值
		 */
		int[] nums = {12,66,3,89,75,45,38,49,96,52};
		/**
		 * 设最大值为X
		 */
		int X = 0;
		for (int i = 0; i < nums.length; i++) {
			if (X < nums[i]) {
				X = nums[i];
			}
		}
		System.out.println("数组nums中的最大值为：" + X);
	}
}

运行结果
在这里插入图片描述

public class Demo07 {
	public static void main(String[] args) {
		/**
		 * @author 豆三岁
		 * 将最大值移动至数组尾部
		 */
		//定义数组nums
		int[] nums = {66,12,96,89,33,45,75,49,3,52};
		//寻找最大值对应的数组下标
		int maxIndex = 0;
		for (int i = 0; i < nums.length; i++) {
			if (nums[maxIndex] < nums[i]) {
				maxIndex = i;
			}
		}
		//交换位置
		int i = nums[maxIndex];
		nums[maxIndex] = nums[nums.length-1];
		nums[nums.length-1] = i;
		//遍历数组查看结果
		for (int x : nums) {
			System.out.print(x+",");
			
		}
	}
}

冒泡排序

在这里插入图片描述

/**
 * @author 豆三岁
 * 冒泡排序（由大到小）
 */
public class Demo09 {
	public static void main(String[] args) {
		//定义数组nums
		int[] nums = {10,12,31,98,21,13,9,7,99}; 
		for (int j = 0; j < nums.length; j++) {
			//定义最小值
			int minIndex = 0;
			for (int i = 0; i < nums.length-j; i++) {
				if (nums[i] < nums[minIndex]) {
					minIndex = i;
				}
			}
			if (minIndex != nums.length-1-j) {
				//需要交换
				int x = nums[minIndex];
				nums[minIndex] = nums[nums.length-1-j];
				nums[nums.length-1-j] = x;
			}
		}
		//遍历数组查看结果
		for (int i : nums) {
			System.out.print(i+",");
		}	
	}
}

运行结果
在这里插入图片描述

/**
 * 冒泡排序（由小到大）
 * 原理:相邻比较
 */
public class Demo08 {
	public static void main(String[] args) {
		//定义数组nums
		int[] nums = {10,12,31,98,21,13,9,7,99}; 
		for (int j = 0; j < nums.length; j++) {
			for (int i = 0; i < nums.length-1; i++) {
				if (nums[i] > nums[i+1] ) {
					//交换位置
					int n = nums[i];
					nums[i] = nums[i+1];
					nums[i+1] = n;
				}
			}
		}
		//遍历数组查看结果
		for (int i : nums) {
			System.out.print(i+",");
		}
	}
}

运行结果
在这里插入图片描述

选择排序

从大到小排序
核心思路：找到最大值，交换其位置
注意事项：已经找到的最值不参与比较与交换

/**
 * @author 豆三岁
 * 选择排序
 * 从大到小排序
 * 并不是找最小值,而是找做大值向左移动
 * 每次找到的最大值,更换到左面后,不应在在继续参与交换
 */
public class Demo10 {
	public static void main(String[] args) {
		//定义数组nums
		int[] nums = {10,12,31,98,21,13,9,7,99}; 
		for (int i = 0; i < nums.length; i++) {
			//定义最大值
			int maxIndex = i;
			for (int j = i; j < nums.length; j++) {
				if (nums[maxIndex] < nums[j]) {
					maxIndex = j;
				}
			}
			//交换位置
			if (i != maxIndex) {
				int n = nums[i];
				nums[i] = nums[maxIndex];
				nums[maxIndex] = n;
			}		
		}
		//遍历数组查找结果
		for (int j : nums) {
			System.out.print(j+",");
		}
		System.out.println();
	}
}

/**
 * @author 豆三岁
 */
public class Demo11 {
	public static void main(String[] args) {
		int[] nums = {10,12,14,8,9,1,99,77,55};
		/**
		 * i的含义:
		 * 		1,本次交换的位置
		 * 		2,i之前下标的数据不参与运算
		 */
		for (int i = 0; i < nums.length; i++) {
			//假设本轮循环获取到的最大值下标为maxIndex
			//注意:i之前的下标对应的数据不参与运算
			int maxIndex = i;
			//循环迭代i以后的数据与假定的最大值下标进行比较,获取真实的最大值下标
			for (int j = i; j < nums.length; j++) {
				if (nums[maxIndex] < nums[j]) {
					maxIndex = j;
				}
			}
			//交换位置
			if (maxIndex != i) {
				int x = nums[maxIndex];
				nums[maxIndex] = nums[i];
				nums[i] = x;
			}
		}
		//遍历数组查看结果
		for (int i : nums) {
			System.out.print(i+",");
		}
	}
}

二分查找

注意：数组必须是有序的

开发中使用的排序

Arrays.sort(数组名)；

import java.util.Arrays;
/**
 * @author 豆三岁
 * 系统提供的排序
 */
public class Demo12 {
	public static void main(String[] args) {
		int[] nums = {99,1,23,14,161,17,19,21,23,2};
		//使用从小到大对数组进行排序
		Arrays.sort(nums);
		for (int i : nums) {
			System.out.print(i+",");
		}
		System.out.println();
		/**
		 * 将已经是从小到大排序的数组,进行翻转
		 */
		int[] nums02 = new int[nums.length];
		for (int i = nums.length-1; i >= 0; i--) {
			int n = nums[i];
			nums02[nums.length-i-1] = n; 
		}
		nums = nums02;
		for (int i : nums) {
			System.out.print(i+",");
		}
	}
}

四、二维数组

作用：将一维数组作为元素的数组
定义：
	语法：数据类型[][] 数组名；
创建：
	静态创建：
		注意：声明与创建必须同时进行
		语法：数据类型[][] 数组名 = {{值1,值2,值3},{值4,值5},{值6,值7,值8,值9},...};
	动态创建：
		先声明，再创建
			数组名 = new 数据类型[一维数组的个数][一维数组中元素的个数];
			一维数组中元素的个数：在创建时可写，可不写
			
			数组名 = new 数据类型[][]{
				{值1,值2,值3,...},                					{值4,值5,...},
                ... 
			}
		声明并创建
			数据类型[][] 数组名 = new 数据类型[一维数组的个数][一维数组中元素的个数];
			一维数组中元素的个数：在创建时可写，可不写
			
            数据类型[][] 数组名 = new 数据类型[][]{
                 {值1,值2,值3,...},
                 {值4,值5,...},
                 ...
            }
使用:
	改:
		元素所在的一维数组在二维数组中的下标
		元素在一维数组中的下标
		数组名[一维数组在二维数组下得下标][元素在一维数组中的下标] = 值;    
	查:
		数组名[一维数组在二维数组下得下标][元素在一维数组中的下标]    
	长度:
        二维数组的长度是其中一维数组的个数
        数组名.length
	遍历:

public class Demo13 {
	public static void main(String[] args) {
		int[][] nums;
		String[][] strs;
		
		//静态创建二维数组
		int[][] nums1 = {
				{1,2,4},
				{3,555,6},
				{1,4,6}
		};
		//动态创建二维数组1
		String[][] strs1;
		strs1 = new String[3][];
		strs1[0] = new String[]{"asds","123","123"};
		strs1[1] = new String[]{"123","678","901"};
		strs1[2] = new String[]{"123456789"};
		//动态创建二维数组2
		strs1 = new String[3][4];
		//动态创建二维数组3
		strs1 = new String[][] {
			{"abc","def"},
			{"123","456","789"}
		};
		System.out.println(strs1[1][0]);
		
	}
}

五、算法

杨辉三角形

1
1   1
1   2   1
1   3   3   1
1   4   6   4   1
1   5   10  10  5   1
1   6   15  20  15  6   1
1   7   21  35  35  21  7   1
1   8   28  56  70  56  28  8   1
9*9的杨辉三角
规律:
    当前位置数 = 上一层该位置数 + 上一层该位置前一个位置的数    
    特殊情况:最左边与斜边为1

/**
 * @author 豆三岁
 *杨辉三角形
 */
public class Demo14 {
	public static void main(String[] args) {
		int[][] nums = new int[9][9];
		for (int i = 0; i < nums.length; i++) {
			for (int j = 0; j < nums[i].length; j++) {
				if (j == 0 || i == j) {
					nums[i][j] = 1;
				}else if (j > 0 && j < i) {
					nums[i][j] = nums[i-1][j] + nums[i-1][j-1];
				}
			}
		}
		/**
		 * 遍历查看结果
		 */
		for (int i = 0; i < nums.length; i++) {
			for (int j = 0; j < nums[i].length; j++) {
				System.out.print(nums[i][j]+"\t");
			}
			System.out.println();
		}
	}
}

运行结果
在这里插入图片描述

豆三岁
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java数组和方法
weixin_59169497的博客
03-06 115
Java中的数组和方法详情
java05数组和方法
TomHaveNoCat的博客
09-12 310
数组 选择排序： 从0下标开始，依次和后面每个元素比较，小的往前放，第一次完毕，最小值出现在了最小下标处 案例： //1.用选择排序将数组中的最小值选出 public static void main(String[] args) { int[] ary = {12,4,54,7,3,8,35,88}; //用一次选择排序，将最小值放到下标0处 for...
java中的方法和数组
最新发布
m0_63660547的博客
04-11 138
a[0]: [0]数组元素的索引, 数组中有length个空间,每个空间都有一个编号,通过编号,就可以访问对应位置的元素.[访问权限修饰符 public, 修饰符static] [方法返回值] 方法名([参数列表 参数类型 参数名]){编号始终是从0开始,最大编号是长度-1,是int类型(数组长度是有限的);数组中元素的访问 (1.给每个位置上的元素进行赋值,2.获取某个位置上的值)for(数组元素的类型 临时变量名字 ：数组的名字){数组的数组---二维数组的每一个元素是一个一维数组。
数组与方法
ylb1327532664的博客
04-05 132
数组：引用类型  一堆相同类型的数据集合一维数组：1、数组的声明：  数据类型名[  ]   变量名 ;2、数组的初始化：（1）静态初始化：  eg :  int[ ]  a ={1,2,3,4 };   静态变量不能再被赋值新的静态值（2）动态初始化：1）  eg:   int [ ] a=new  int  [length];   会有length 个默认值整形：0   浮点型  0.0  字...
Java_数组定义及常用方法
810364804
12-12 185
Java_数组定义及常用方法 摘要： 从数组的一些简单介绍、到定义、声明、初始化、以及常用的方法、细微的区别、但是没有讲多维数组、多维数组本质是一维数组的延伸、以后有时间补充、有补充或者误导的地方望不吝指正、不胜感激！ 一：数组的简介 Java中的数组、是一种简单的线性数据存储结构、他用牺牲自动扩展大小来换取与集合相比的唯一优势——查询效率的提升。他本身是一种引用类型的...
java基础——数组及其应用（csdn）————程序.pdf
12-01
总之，数组是Java编程中的基础元素，理解其原理和使用方法对于学习和使用Java至关重要。数组提供了高效的数据存储和访问方式，但其固定的长度和对类型的要求也限制了其在某些特定场景下的灵活性。
JAVA基础知识学习——方法与数组
03-30
自我学习的总结
java——数组.xmind
07-10
一维数组概念：一组连续的存储空间，存储多个相同数据类型的值。数组的创建。数组的组成。数组的遍历。数组的默认值。
Java语言程序设计讲义——数组与字符串
12-17
这一款整理发布的Java语言程序设计讲义——数组与字符串，适用于日常学习、参考、借鉴Java语言...该文档为Java语言程序设计讲义——数组与字符串，是一份很不错的参考资料，具有较高参考价值，感兴趣的可以下载看看
动力节点老杜Java基础入门学习教程分享——数组
09-16
### 动力节点老杜Java基础入门学习教程分享——数组 #### 数组概要 数组是一种重要的数据结构，被广泛应用于各种编程语言中，包括Java。数组是一种引用数据类型，用于存储固定数量的同类型元素。在内存中，数组是...
5-Java数组与方法
04-30
本章主要介绍数组的概念及定义，并简单介绍了数组的引用传递，及数组的动态、静态初始化及二维数组的定义和使用。
Java数组与方法
qq_41590178的博客
04-29 2776
** 一维数组 ** 数组的初始化：静态初始化、动态初始化 静态初始化：在声明时指定数组内容 数组类型 数据名[] = {初始值1，初始值2，…} int num[]={1,2,3} 动态初始化：先声明再赋值。 数组默认值 int[]->0 , double->0.0 , boolean[]->false , char[]->编码为0的控制字符 数组堆与栈 ** 二维数...
java数组与方法
xiao_ma123的专栏
09-20 769
1.一维数组的声明与分配内存 数据类型 数组名[ ] ； // 声明一维数组 数组名 = new 数据类型[个数] ; // 分配内存给数组 例： int array[ ]; array = new int[3]; 2.声明数组的同时分配内存 数据类型 数组名[] =  new 数据类型[个数]; 例： int array[ ] = new int[3];  3.数组长度的取得
3. JAVA数组与方法
chengchenghao的博客
09-28 178
1数组的定义          数组是一组相关数据的集合，一个数组实际上就是一连串的变量，数组按照使用可以分为一维数组、二维数组、多维数组。  数组的优点：         不使用数组定义100个整型变量：int i1;int i2;…int i100          使用数组定义：int i[100] 1.1一维数组        一维数组可以存放上千万个数据，并且这些数据的类...
java 数组的方法_Java—数组和方法
weixin_31209173的博客
02-20 182
数组声明数组　　数组类型[] 数组名;or 数据类型 数组名[]; 如：int[] scores;分配空间　　数组名 = new 数据类型[数组长度];如：scores = new int[5];以上两步合并：int[] scores = new int[5];3. 赋值　　scores[0] = 76;以上三步合并：int[] scores = {76, 80, 81, 82, 99};等价于i...
JAVA学习笔记day03
qq_41988770的博客
01-04 169
1.数组 1.1什么是数组 数组（array)是一种用于存储多个相同类型数据的存储模型。 1.2数组的定义格式 格式一：数组类型[] 变量名； 范例：int[] arr； 定义了一个int类型的数组，数组名是arr 格式二：数据类型 变量名[]; 范例：int arr[]; 定义了一个int类型的变量，变量名是arr数组 1.3数组的初始化之动态初始化 1.3.1数组初始化概述 java中数组必须先初始化，然后才能使用 所谓初始化：就是为数组中的数组元素分配内存空间，...
Java基础：数组操作与排序算法实现
本资源主要介绍了几个与数组处理和排序算法相关的实用方法，这些都是Java初学者需要掌握的基本技能。 首先，我们来看一个名为`ArrayTool`的类，这个类提供了一些静态方法来处理整型数组。`ArrayTool`类中的`getMax`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值