对Java打比赛和做题有用的API以及模版(个人总结)

以下是我打比赛常用的API，以及一些实用小技巧和常识，有些久了不用可能会忘，所以想在这里记录一下，也可以供大家参考

import java.math.BigInteger;
import java.time.Instant;
import java.util.*;

public class Text {
	public static void main(String[] args) {
		//--------------------1
		//求a/b向上取整
		//7  2  -> 4
		int a = 7,b = 2;
		System.out.println((a+b-1)/b);
		
		//--------------------2
		//将一个double类型的小数保留两位，并以字符串形式返回
		String s = String.format("%.2f", 4.567);//四舍五入
		System.out.println(s);
		
		//闰年二月多少天，如何判断闰年
		/*29,非整百能被4整除，整百能被400整除的年份为闰年*/
		
		//--------------------3
		//申请一个小顶堆
		PriorityQueue<Integer> dui = new PriorityQueue<Integer>((a1,b1)->a1.compareTo(b1));//括号中的compareTo语句可省略，PriorityQueue默认是升序排序
		//申请一个装Double的大顶堆
		PriorityQueue<Double> bigDui = new PriorityQueue<>((a1,a2)->a2.compareTo(a1));
		bigDui.offer(1.23);
		bigDui.offer(4.65);
		bigDui.offer(8.88);
		System.out.println(bigDui);
		
		//--------------------4
		//集合的条件排序
		List<Integer> list = new ArrayList<>();
		Collections.sort(list,(a1,a2)->a2-a1);
		Collections.sort(list,(a1,a2)->{
			if(Math.abs(a1-a2) > 0){
				return a1-a2;
			}else{
				return a2-a1;
			}
		});
		
		//--------------------5
		//将一个数组复制
		int[] arr = {1,3,5,2,4};
		int[] copyArr = Arrays.copyOfRange(arr, 0, arr.length);
		//比较两个数组元素是否完全相等
		System.out.println(Arrays.equals(arr, copyArr));
		
		//--------------------6
		String s6 = "IFDgOgj";
		//将字符串转化为纯大写字符串
		System.out.println(s6.toUpperCase());
		//将字符串转换为纯小写字符串
		System.out.println(s6.toLowerCase());
		
		//--------------------7
		//用正则实现将分割符设置为所有非大小写字母的字符串
		String s7 = "IGD.Ij jg sSI,DG.jg?d";
		String[] srr = s7.split("[^a-zA-Z]+");
		System.out.println(Arrays.toString(srr));//[IGD,Ij,jg,sSI,DG,jg,d]
		
		//--------------------8
		String s8 = "123456";
		//切割字符串的第2,3,4个字符作为新字符串
		System.out.println(s8.substring(1,4));
		//将字符数组的指定索引区间转换为字符串
		char[] crr = {'1','2','3','4','5'};
		System.out.println(new String(crr,1,3));
		//比较两个字符串字典序的大小
		System.out.println("123".compareTo("234"));//-1
		
		//--------------------9
		//在打印时保留两位小数，四舍五入
		System.out.printf("%.2f\n",(double)5.678);
		//求3为底 27 的对数
		System.out.println(Math.log(27)/Math.log(3));//3.0
		//从0~100,闭区间中随机生成一个数
		System.out.println((int)(Math.random()*101));//Math.Random() 随机生成[0,1)的小数
		
		//--------------------10
		//利用 Arrays 快速创建一个 List<>()
		List<Integer> list10 = Arrays.asList(9,5,2,1);
		//交换集合的两个元素
		Collections.swap(list10, 0, 3);
		System.out.println(list10);//1 5 2 9
		//根据元素之间的绝对值之差进行排序
		Collections.sort(list10,(a1,b1)->(Math.abs(a1-b1)));
		System.out.println(list10);//1 5 2 9
		//查找集合中对应元素的索引
		System.out.println(list10.indexOf(9));//3
		
		//--------------------11
		int n = 64;
		//拿到 n 的二进制字符串中 1 的个数
		System.out.println(Integer.bitCount(n));
		//将十进制转换为二进制
		System.out.println(Integer.toBinaryString(n));
		//将十进制转换为八进制
		System.out.println(Integer.toOctalString(n));
		//将十进制转换为十六进制
		System.out.println(Integer.toHexString(n));
		
		//--------------------12
		//BigInteger 做减法
		String s12 = BigInteger.valueOf(5).subtract(BigInteger.valueOf(2)).toString();//3
		//BigInteger 做除法
		String s122 =  BigInteger.valueOf(5).divide(BigInteger.valueOf(2)).toString();//2
		System.out.println(s12 + " " + s122);
		
		//--------------------13
		PriorityQueue<Long> dui13 = new PriorityQueue<>();
		dui13.offer(520L);
		//判断优先队列是否包含 value 元素
		System.out.println(dui13.contains(520L));//true
		//删除优先队列的 value 元素
		dui13.remove(520L);
		System.out.println(dui.size());//0
		
		//--------------------14
		//利用API判断 2024年4月13日是星期几
		Calendar c = Calendar.getInstance();
		c.set(2024,3,13);//0代表一月
		System.out.println(c.get(Calendar.DAY_OF_WEEK));//7，1代表星期日
		//将一个long类型的毫秒值时间转换为年月日时分秒的形式
		Instant instant = Instant.ofEpochMilli(System.currentTimeMillis());
		System.out.println(instant.toString());
		
		//--------------------15
		//写出一个埃氏筛判断 100000 内的质数与非质数情况
		class aishishai{
			int n = 100;
			boolean[] bool = new boolean[n+1];//判断0-100000
			{
				for(int i=2;i<=n;i++){//外层枚举最小的质数
					if(bool[i])continue;//若不是质数直接跳过避免多余计算
					for(int j=i;j<=n/i;j++){//内层将最小质数得到的所有非质数标记
						bool[j*i] = true;
					}
				}
				bool[0] = bool[1] = true;
			}
		}
		aishishai as = new aishishai();
		for(int i=0;i<as.bool.length;i++){
			if(!as.bool[i]){
				System.out.print(i+" ");
			}
		}
		System.out.println();
		
		//--------------------16
		//求2024^2024的末尾3位，BigInteger底层是快速幂实现的，故无需被快速幂的模版，直接调用API即可
		String s16 =  BigInteger.valueOf(2024L).modPow(BigInteger.valueOf(2024L), BigInteger.valueOf(1000)).toString();
		System.out.println(s16);//776
		
		//--------------------17
		//求最小公倍数
		//15 18
		System.out.println(lcm(15,18));//90
		
		//--------------------18
		//求{1,2,3,4,5}的取2个数的组合、排列、子集
		int[] arr18 = {1,2,3,4,5};
		dfs1(0,new int[2],0,arr18);
		System.out.println("-----------");
		dfs2(arr18,new int[arr18.length],new boolean[arr18.length],0);
		System.out.println("-----------");
		dfs3(0,new ArrayList<>(),arr18,0);
	}
	static void dfs3(int left,List<Integer> path,int[] arr,int len){
		System.out.println(path);
		for(int i=left;i<arr.length;i++){
			path.add(arr[i]);
			dfs3(i+1,path,arr,len+1);
			path.remove(path.size()-1);
		}
	}
	static void dfs1(int left,int[] path,int len,int[] arr){
		if(len == path.length){
			System.out.println(Arrays.toString(path));
			return;
		}
		for(int i=left;i<arr.length;i++){
			path[len] = arr[i];
			dfs1(i+1,path,len+1,arr);
		}
	}
	static void dfs2(int[] arr,int[] path,boolean[] bool,int len){
		if(len == path.length){
			System.out.println(Arrays.toString(path));
			return;
		}
		for(int i=0;i<arr.length;i++){
			if(!bool[i]){
				bool[i] = true;
				path[len] = arr[i];
				dfs2(arr,path,bool,len+1);
				bool[i] = false;
			}
		}
	}
	static int gcd(int a,int b){
		if(a == 0 || b == 0){
			return a == 0 ? b : a;
		}
		return gcd(b,a%b);
	}
	static int lcm(int a,int b){
		return a*b / gcd(a,b);
	}
}

以上程序的运行结果：

4
4.57
[8.88, 1.23, 4.65]
true
IFDGOGJ
ifdgogj
[IGD, Ij, jg, sSI, DG, jg, d]
234
234
-1
5.68
3.0
63
[1, 5, 2, 9]
[1, 5, 2, 9]
3
1
1000000
100
40
3 2
true
0
7
2024-04-15T11:17:28.122Z
2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97 
776
90
[1, 2]
[1, 3]
[1, 4]
[1, 5]
[2, 3]
[2, 4]
[2, 5]
[3, 4]
[3, 5]
[4, 5]
-----------
[1, 2, 3, 4, 5]
[1, 2, 3, 5, 4]
[1, 2, 4, 3, 5]
[1, 2, 4, 5, 3]
[1, 2, 5, 3, 4]
[1, 2, 5, 4, 3]
[1, 3, 2, 4, 5]
[1, 3, 2, 5, 4]
[1, 3, 4, 2, 5]
[1, 3, 4, 5, 2]
[1, 3, 5, 2, 4]
[1, 3, 5, 4, 2]
[1, 4, 2, 3, 5]
[1, 4, 2, 5, 3]
[1, 4, 3, 2, 5]
[1, 4, 3, 5, 2]
[1, 4, 5, 2, 3]
[1, 4, 5, 3, 2]
[1, 5, 2, 3, 4]
[1, 5, 2, 4, 3]
[1, 5, 3, 2, 4]
[1, 5, 3, 4, 2]
[1, 5, 4, 2, 3]
[1, 5, 4, 3, 2]
[2, 1, 3, 4, 5]
[2, 1, 3, 5, 4]
[2, 1, 4, 3, 5]
[2, 1, 4, 5, 3]
[2, 1, 5, 3, 4]
[2, 1, 5, 4, 3]
[2, 3, 1, 4, 5]
[2, 3, 1, 5, 4]
[2, 3, 4, 1, 5]
[2, 3, 4, 5, 1]
[2, 3, 5, 1, 4]
[2, 3, 5, 4, 1]
[2, 4, 1, 3, 5]
[2, 4, 1, 5, 3]
[2, 4, 3, 1, 5]
[2, 4, 3, 5, 1]
[2, 4, 5, 1, 3]
[2, 4, 5, 3, 1]
[2, 5, 1, 3, 4]
[2, 5, 1, 4, 3]
[2, 5, 3, 1, 4]
[2, 5, 3, 4, 1]
[2, 5, 4, 1, 3]
[2, 5, 4, 3, 1]
[3, 1, 2, 4, 5]
[3, 1, 2, 5, 4]
[3, 1, 4, 2, 5]
[3, 1, 4, 5, 2]
[3, 1, 5, 2, 4]
[3, 1, 5, 4, 2]
[3, 2, 1, 4, 5]
[3, 2, 1, 5, 4]
[3, 2, 4, 1, 5]
[3, 2, 4, 5, 1]
[3, 2, 5, 1, 4]
[3, 2, 5, 4, 1]
[3, 4, 1, 2, 5]
[3, 4, 1, 5, 2]
[3, 4, 2, 1, 5]
[3, 4, 2, 5, 1]
[3, 4, 5, 1, 2]
[3, 4, 5, 2, 1]
[3, 5, 1, 2, 4]
[3, 5, 1, 4, 2]
[3, 5, 2, 1, 4]
[3, 5, 2, 4, 1]
[3, 5, 4, 1, 2]
[3, 5, 4, 2, 1]
[4, 1, 2, 3, 5]
[4, 1, 2, 5, 3]
[4, 1, 3, 2, 5]
[4, 1, 3, 5, 2]
[4, 1, 5, 2, 3]
[4, 1, 5, 3, 2]
[4, 2, 1, 3, 5]
[4, 2, 1, 5, 3]
[4, 2, 3, 1, 5]
[4, 2, 3, 5, 1]
[4, 2, 5, 1, 3]
[4, 2, 5, 3, 1]
[4, 3, 1, 2, 5]
[4, 3, 1, 5, 2]
[4, 3, 2, 1, 5]
[4, 3, 2, 5, 1]
[4, 3, 5, 1, 2]
[4, 3, 5, 2, 1]
[4, 5, 1, 2, 3]
[4, 5, 1, 3, 2]
[4, 5, 2, 1, 3]
[4, 5, 2, 3, 1]
[4, 5, 3, 1, 2]
[4, 5, 3, 2, 1]
[5, 1, 2, 3, 4]
[5, 1, 2, 4, 3]
[5, 1, 3, 2, 4]
[5, 1, 3, 4, 2]
[5, 1, 4, 2, 3]
[5, 1, 4, 3, 2]
[5, 2, 1, 3, 4]
[5, 2, 1, 4, 3]
[5, 2, 3, 1, 4]
[5, 2, 3, 4, 1]
[5, 2, 4, 1, 3]
[5, 2, 4, 3, 1]
[5, 3, 1, 2, 4]
[5, 3, 1, 4, 2]
[5, 3, 2, 1, 4]
[5, 3, 2, 4, 1]
[5, 3, 4, 1, 2]
[5, 3, 4, 2, 1]
[5, 4, 1, 2, 3]
[5, 4, 1, 3, 2]
[5, 4, 2, 1, 3]
[5, 4, 2, 3, 1]
[5, 4, 3, 1, 2]
[5, 4, 3, 2, 1]
-----------
[]
[1]
[1, 2]
[1, 2, 3]
[1, 2, 3, 4]
[1, 2, 3, 4, 5]
[1, 2, 3, 5]
[1, 2, 4]
[1, 2, 4, 5]
[1, 2, 5]
[1, 3]
[1, 3, 4]
[1, 3, 4, 5]
[1, 3, 5]
[1, 4]
[1, 4, 5]
[1, 5]
[2]
[2, 3]
[2, 3, 4]
[2, 3, 4, 5]
[2, 3, 5]
[2, 4]
[2, 4, 5]
[2, 5]
[3]
[3, 4]
[3, 4, 5]
[3, 5]
[4]
[4, 5]
[5]

以上便是我目前所用过的API以及常用模型，后面遇到了新的实用的算法或者API再更新吧