本文详细介绍了Java中的函数和方法定义，包括静态方法、参数传递、日期格式化、UUID生成、整数操作（最大值、位数、数组操作）、排序算法（冒泡排序、二分查找）以及数组旋转和查找功能。
自定函数(方法)
函数(方法):
给定一个具有独立功能的代码片段进行"命名",并通过该该类名调用"方法"
main主函数
在当前类中,可以直接调用方法(因为方法使用了static关键字)
package study;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.UUID;
public class Demo01 {
// 自定函数(方法)
// 函数(方法):给定一个具有独立功能的代码片段进行"命名",并通过该该类名调用"方法"
public static void createorderNo() {
// 生成一个订单编号
// 订单编号格式规则:
// 当前日期+流水号(5位随机数字+字母)
// 例如:20240115AX32B
// 当前日期:获取当前日期,并转换成字符串
// 方式1:
// toString():按照默认日期个数yyyy-MM-dd,转换成字符串
// String orderNo = LocalDate.now().toString();
// 方式2:
// format()按照指定日期格式yyyy年MM月dd日,转换成字符串
// String orderNo = LocalDate.now().format(DateTimeFormatter.ofPattern("yyyy年MM月dd日"));
// format()按照指定日期格式yyyyMMdd,转换成字符串
String orderNo = LocalDate.now().format(DateTimeFormatter.ofPattern("yyyyMMdd"));
System.out.println(orderNo);
// 流水号:
String traceId = UUID.randomUUID().toString().substring(0,5).toUpperCase();
System.out.println(traceId);
// 订单编号=当前日期+流水号
orderNo = orderNo + traceId;
System.out.println("新订单编号:" + orderNo);
}
// main主函数
public static void main(String[] args) {
// 在当前类中,可以直接调用方法(因为方法使用了static关键字)
createorderNo();
}
}
运行结果：
20240306
93F3C
新订单编号:2024030693F3C
Demo02调用Demo01类的createorderNo()，需要通过"类名.方法名"调用
package study;
public class Demo02 {
public static void main(String[] args) {
// 创建新订单编号
// 调用Demo01类的createorderNo()
// 需要通过"类名.方法名"调用
Demo01.createorderNo();
}
}
运行结果：
20240306
C8560
新订单编号:20240306C8560
定义方法语法结构
访问修饰符[private/public] static 返回值类型 方法名称(参数){ }
[访问修饰符]: 代表该方法可以使用的范围
[static关键字]: 该方法通过类名调用(如果是在当前类类，可以直接调用，类名省略)
[返回值类型]:该方法调用后，产生并返回的结果类型(如果没有返回值，需要使用void)
[方法名称]: 按照该方法的作用，为方法命名
[方法参数]: 按照该方法的作用，为方法设计参数的个数和类型
方法的定义
查找3个int类型参数中的最大值
package study;
public class Demo03 {
// 方法的定义
// 查找3个int类型参数中的最大值
public static int max(int a,int b,int c) {
int ret = a>b?(a>c?a:c):(b>c?b:c);
return ret;
}
public static void main(String[] args) {
// 方法的调用
int val1 = max(23,11,45);
System.out.println("结果1:"+val1);
int val2 = max(21,17,5);
System.out.println("结果2:"+val2);
}
}
运行结果：
结果1:45
结果2:21
动态查找
查找N个int类型整数中的最大值
package study;
public class Demo04 {
// 动态查找
// 查找N个int类型整数中的最大值
private static int maxN(int... ns) {
int ret = ns[0];
for(int i = 1;i < ns.length;i++) {
if(ns[i] > ret) {
ret = ns[i];
}
}
return ret;
}
public static void main(String[] args) {
// 可以传入N个整数
int max = maxN(4,33,55,66,128,41);
System.out.println(max);
}
}
运行结果：
128两数之和参数
target : 需要查找的目标值参数
numbers : 需要查找的一组整数(动态参数)
注意: 动态参数必须是整个参数列表的最后1部分
package study;
public class Demo05 {
public static void main(String[] args) {
String ret = twoSum(5,1,4,2,3,5,6,7,8,9);
System.out.println(ret);
}
public static String twoSum(int target,int... numbers) {
String result = "";
outter:
for(int i = 0;i <numbers.length-1;i++) {
for(int k =i+1;k<numbers.length;k++) {
if(numbers[i]+numbers[k] == target) {
//1+4=5
//result = numbers[i]+"+"+numbers[k]+"="+(numbers[i]+numbers[k]);
//String.format():格式化拼接
result = String.format("%d+%d=%d",numbers[i],numbers[k],numbers[i]+numbers[k]);
//方式1
//break outter;
//方式2
return result;
}
}
}
return result;
}
}
运行结果：
1+4=5通过方法的调用逆序字符串
package study;
public class Demo06 {
public static void main(String[] args) {
//方法的调用
String ret = reverse("忽如一夜春风来");
System.out.println(ret);
}
//方法的定义
//字符串逆序
//参数s:原始字符串
public static String reverse(String s) {
String ret = "";
// for(int i = 0;i <s.length();i++) {
// char c = s.charAt(i);
// ret = c+ret;
// }
for(int i = s.length()-1;i>=0;i--) {
char c = s.charAt(i);
ret = ret + c;
}
return ret;
}
}
运行结果：
来风春夜一如忽
通过循环计算整数的位数
package study;
public class Demo07 {
public static void main(String[] args) {
int n1 = 12345;
int len1 = numberLength(n1);
System.out.println(n1+"的长度是"+len1+"位！");
int n2 = 789456;
int len2 = numberLength(n2);
System.out.printf("%d的长度是%d位！",n2,len2);
}
public static int numberLength(int number) {
//方式1:计算该整数以10为底的对数
//int ret = (int)Math.log(number) + 1;
//return ret;
//方式2:通过循环
int ret = 0;
while(number != 0) {
System.out.println("个位数值:" + number%10);
ret++;
number = number / 10;
}
return ret;
}
}
运行结果：
运行结果：
个位数值:5
个位数值:4
个位数值:3
个位数值:2
个位数值:1
12345的长度是5位！
个位数值:6
个位数值:5
个位数值:4
个位数值:9
个位数值:8
个位数值:7
789456的长度是6位！方法的传参
基本数据类型的参数:传递"值"
引用数据类型的参数:传递"内存地址"
package study;
import java.util.Arrays;
public class Demo09 {
public static void main(String[] args) {
//定义数组,保存一组"需要进行的扩容"的整数
int[] array = {1,2,3,4,5};
System.out.println("改变前:"+Arrays.toString(array));
System.out.println("数组array的内存地址:" + array);
//引用数据类型的传参
//array传递的是"内存地址"
grow2(array);
System.out.println("改变后:"+Arrays.toString(array));
}
//引用数据类型的传参
//参数numbers接收的是"内存地址"
public static void grow2(int[] numbers) {
System.out.println("数组numbers的内存地址:" + numbers);
for(int i = 0;i < numbers.length;i++) {
numbers[i] = numbers[i] << 1;
}
System.out.printf("改变中");
for(int n : numbers) {
System.out.println(n + "\t");
}
System.out.println();
}
}
运行结果：
改变前:[1, 2, 3, 4, 5]
数组array的内存地址:[I@7de26db8
数组numbers的内存地址:[I@7de26db8
改变中2
4
6
8
10
改变后:[2, 4, 6, 8, 10]通果冒泡排序和二分查找查找数组中的目标元素
package study;
import java.util.Arrays;
public class Demo10 {
public static void main(String[] args) {
int[] arr = {4,3,1,23,12,8,17,7,5};
// System.out.println("排序前:"+Arrays.toString(arr));
// sort(arr);
// System.out.println("排序后:"+Arrays.toString(arr));
//查找
int ret = binarySearch(arr,3);
System.out.println("查找的目标值在数组的下标="+ret);
}
//冒泡排序
public static void sort(int[] ns) {
for(int i = 0,n = ns.length;i<n-1;i++) {
boolean isSort = true;
for(int k = 0;k < n-1-i;k++) {
if(ns[k] > ns[k+1]) {
ns[k] = ns[k] ^ ns[k+1];
ns[k+1] = ns[k] ^ ns[k+1];
ns[k] = ns[k] ^ ns[k+1];
isSort = false;
}
}
if(isSort) {
break;
}
}
}
//查找(二分查找算法)
//参数ns : 要查找的目标数组
//参数target : 在目标数组中查找的目标值
//返回值:返回目标值在目标数组中的下标，如果不存在，则返回-1
public static int binarySearch(int[] ns,int target) {
//先排序
sort(ns);//在一个方法中调用另一个方法
//再二分查找
int low = 0,high = ns.length-1;
while(low <= high) {
int mid = (low + high) >> 1;
if(ns[mid] == target) {
return mid;
}else if(ns[mid] < target) {
low = mid+1;
}else if(ns[mid] >target) {
high = mid-1;
}
}
return -1;
}
}
运行结果：
查找的目标值在数组的下标=1
数组旋转调用方法
package study;
import java.util.Arrays;
public class Demo11 {
public static void main(String[] args) {
int[] numbers = {1,2,3,4,5,6,7};
System.out.println("原始数组"+Arrays.toString(numbers));
right(numbers,3);
System.out.println("向左旋转"+Arrays.toString(numbers));
right(numbers,2);
System.out.println("向右旋转"+Arrays.toString(numbers));
}
// 向右旋转:把尾元素，通过不断交换，移动到数组的"头部"
public static void right(int[] ns,int n) {
// 向右旋转几次
for(int i = 1;i <= n;i++) {
for(int k = ns.length-1;k >0;k--) {
//每次向右旋转1位
ns[k] = ns[k] ^ ns[k-1];
ns[k-1] = ns[k] ^ ns[k-1];
ns[k] = ns[k] ^ ns[k-1];
}
}
}
//向左旋转:把头元素，通过不断交换，移动到数组的"尾部"
public static void left(int[] ns,int n) {
for(int i = 1;i <= n;i++) {
for(int k = 0;k < ns.length-1;k++) {
ns[k] = ns[k] ^ ns[k+1];
ns[k+1] = ns[k] ^ ns[k+1];
ns[k] = ns[k] ^ ns[k+1];
}
}
}
}
运行结果：
原始数组[1, 2, 3, 4, 5, 6, 7]
向左旋转[5, 6, 7, 1, 2, 3, 4]
向右旋转[3, 4, 5, 6, 7, 1, 2]使用数组,返回查找到的两个下标
package study;
import java.util.Arrays;
public class Demo12 {
public static void main(String[] args) {
int[] retArr = twoSum(5,1,4,2,3,5,6,7,8,9);
System.out.println(Arrays.toString(retArr));
}
//使用数组,返回查找到的两个下标
public static int[] twoSum(int target,int... numbers) {
int[] rets = {-1,-1};
outter:
for(int i = 0;i <numbers.length-1;i++) {
for(int k =i+1;k<numbers.length;k++) {
if(numbers[i]+numbers[k] == target) {
rets[0] = i;
rets[1] = k;
break outter;
}
}
}
return rets;
}
}
运行结果：
[0, 1]
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
