【蓝桥杯Java技巧】_csdn 蓝桥杯技巧 java

1、进制转换

1.1 十进制转其它进制

Integer.toString(k,r)，将十进制的k，转换为r进制的String。返回String

System.out.println(Integer.toString(10, 2));
System.out.println(Integer.toString(10, 3));
// 输出
// 1010
// 101
1
2
3
4
5

1.2 其它进制数转十进制

Integer.parseInt(str, r)，将r进制数的字符串str转换为十进制的数。返回Integer

System.out.println(Integer.parseInt("1010", 2));
System.out.println(Integer.parseInt("101", 3));
// 输出
// 10
// 10
1
2
3
4
5

2、String类

2.1 字符串比较

这个应该都知道，用equals，==是判断地址

2.2 查找子串

• 是否包含字串：contains()
  

• 查看子串是否在母串的开始：startsWith()
  

• 查看子串是否在母串的最后：endsWith()
  

• 查找子串第一次出现的下标，从下标0开始：indexOf()，没有找到返回-1
  

• 查找子串最后一次出现的下标：lastIndexOf()
  

• 提取子串：substring()
  

2.3 String和char[]的相互转换

String str = "Hello,World!";
char[] chrs = str.toCharArray();
String strr = new String(chrs);
1
2
3

如果修改了char[]数组，String并不会改变。因为通过new String(char[])创建新的String实例时，它并不会直接引用传入的char[]数组，而是会复制一份，所以，修改外部的char[]数组不会影响String实例内部的char[]数组，因为这是两个不同的数组。

2.4 StringBuffer和StringBuilder

两者的使用是没有区别的。所以，会用其一即可。但由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。

以下是一些常见的函数：

StringBuilder strB = new StringBuilder();

//1、append(String str)/append(Char c)：字符串连接
System.out.println("StringBuilder:"+strB.append("ch").append("111").append('c'));
//return "StringBuilder:ch111c"

//2、toString()：返回一个与构建起或缓冲器内容相同的字符串
System.out.println("String:"+strB.toString());
//return "String:ch111c"

//3、appendcodePoint(int cp)：追加一个代码点，并将其转换为一个或两个代码单元并返回this
System.out.println("StringBuilder.appendCodePoint:"+strB.appendCodePoint(2));
//return "StringBuilder.appendCodePoint:ch111c"

//4、setCharAt(int i, char c)：将第 i 个代码单元设置为 c（可以理解为替换）
strB.setCharAt(2, 'd');
System.out.println("StringBuilder.setCharAt:" + strB);
//return "StringBuilder.setCharAt:chd11c"

//5、insert(int offset, String str)/insert(int offset, Char c)：在指定位置之前插入字符(串)
System.out.println("StringBuilder.insertString:"+ strB.insert(2, "LS"));
//return "StringBuilder.insertString:chLSd11c"
System.out.println("StringBuilder.insertChar:"+ strB.insert(2, 'L'));
//return "StringBuilder.insertChar:chLLSd11c"

//6、delete(int startIndex,int endIndex)：删除起始位置（含）到结尾位置（不含）之间的字符串
System.out.println("StringBuilder.delete:"+ strB.delete(2, 4));
//return "StringBuilder.delete:chSd11c"
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

3、BigInteger与BigDecimal

3.1 BigInteger

面对一些大整数题目可以直接使用

import java.math.BigInteger;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
//        Scanner scan = new Scanner(System.in);
//        // 读入字符串
//        String str = scan.next();
        // 传入字符串才能形成大数，默认是把字符串当成十进制
        BigInteger bs = new BigInteger("15666666666666666");
        BigInteger bs1 = new BigInteger("100002123123123");
        // 1、求两个大整数的和（必须传入大整数类型）
        System.out.println(bs.add(bs1));
        // 2、divide，返回两个大整数的商
        System.out.println(bs.divide(bs1));
        // 3、mod，取模（余数）
        System.out.println(bs.mod(bs1));
        // 4、返回大整数的double、float类型
        System.out.println(bs.doubleValue());
        // 5、返回大整数的最大公约数
        System.out.println(bs.gcd(bs1));
        // 6、返回两个大整数的乘积
        System.out.println(bs.multiply(bs1));
        // 7、返回当前大整数除以val的余数
        System.out.println(bs.remainder(bs1));
        // 8、返回两个大整数相减的结果
        System.out.println(bs.subtract(bs1));
        // 9、将当前大整数转成十进制字符串形式
        System.out.println(bs.toString());
        // 也可以把字符串当成二进制传入，生成十进制大数
        BigInteger bs2 = new BigInteger("100000", 2);
        System.out.println(bs2);

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

3.2 BigDecimal（除法精度问题）

对BigDecimal做加、减、乘时，精度不会丢失，但是做除法时，存在无法除尽的情况，这时，就必须指定精度以及如何进行截断。

package Chapter_5;

import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.RoundingMode;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        // 大小数
        BigDecimal bs = scan.nextBigDecimal();
        // 获取小数位数，如果是整数则输出负数，表示末尾0的个数
        System.out.println(bs.scale());
        // 去掉小数末尾无用的0
        System.out.println(bs.stripTrailingZeros());
        // 设置小数位数，可以选择四舍五入或者直接截断
        System.out.println(bs.setScale(4, RoundingMode.HALF_UP));  // 四舍五入
        // 对BigDecimal做加、减、乘时，精度不会丢失，但是做除法时，存在无法除尽的情况，这时，就必须指定精度以及如何进行截断。
        BigDecimal d1 = new BigDecimal("123.456");
        BigDecimal d2 = new BigDecimal("23.456789");
        BigDecimal d3 = d1.divide(d2, 10, RoundingMode.HALF_UP); //保留10位小数并四舍五入
        BigDecimal d4 = d1.divide(d2); // 报错：ArithmeticException，因为除不尽
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

3.3 比较BigDecimal

如果使用equlas需要保证整数、小数位数一样，可以直接使用compareTo()方法来比较，它根据两个值的大小分别返回负数、正数和0，分别表示小于、大于和等于。总是使用compareTo()比较两个BigDecimal的值，不使用equals()。

BigDecimal d1 = new BigDecimal("123.456");
BigDecimal d2 = new BigDecimal("123.45600");
System.out.println(d1.equals(d2)); // false,因为scale不同
System.out.println(d1.equals(d2.stripTrailingZeros()));// true,因为d2去除尾部0后scale变为2
System.out.println(d1.compareTo(d2)); // 0
1
2
3
4
5

4、Date类（日期）

4.1 Date对象的生成

• 传入毫秒数

Date date = new Date();
System.out.println(date);
// 传入从1970年1月1日起的毫秒数
Date date1 = new Date(100000);
System.out.println(date1);
1
2
3
4
5

• 传入距离1899年12月31日的年月日

Date date = new Date();
System.out.println(date);
// 传入距离1899 12 31的年、月、日
Date date1 = new Date(0,0,0);
System.out.println(date1);
// 1900 12 31
Date date2 = new Date(1,0,0);
System.out.println(date2);
// 1900 1 1
Date date3 = new Date(0,0,1);
System.out.println(date3);
1
2
3
4
5
6
7
8
9
10
11

• 通过SimpleDateFormat把String转成Date

String s1 = "2021-7-24";
String s2 = "2022-7-24";
//yyyy-MM-dd，注意MM必须大写
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
// 转换成date1需要抛出异常
Date date1 = sdf.parse(s1);
Date date2 = sdf.parse(s2);
System.out.println(date1);
System.out.println(date1.after(date2));
System.out.println(date1.equals(date2));
1
2
3
4
5
6
7
8
9
10

4.2 日期和时间的格式化编码

使用 SimpleDateFormat 格式化日期。SimpleDateFormat 是一个以语言环境敏感的方式来格式化和分析日期的类。SimpleDateFormat 允许你选择任何用户自定义日期时间格式来运行。

Date date = new Date(120000000);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
System.out.println(sdf.format(date));
1
2
3

注意MM是月份，mm是分钟，HH是24小时制、hh是12小时制，ss是秒

Date date = new Date(120000000);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss");
System.out.println(sdf.format(date));
1
2
3

5、Calender类（日历）

Calender的月份MONTH是从0开始，也就是1-12月对应 0-11，但日期和年份是从1开始的。DAY_OF_WEEK从1开始，也就是周日到周六对应 1-7。

周日是1，周一是2，周六是7。1月是0，12月是11。

Calender对象的get使用方法：

// 默认是当前日期
Calendar c = Calendar.getInstance();
// 也可以手动设置:2021nian7yue13ri
c.set(2021, 7 - 1, 1);
System.out.println(c.get(Calendar.YEAR));
System.out.println(c.get(Calendar.MONTH) + 1);
System.out.println(c.get(Calendar.DATE));
// 星期几，1是星期日
System.out.println(c.get(Calendar.DAY_OF_WEEK));
// 这个月的第几天，从1开始算
System.out.println(c.get(Calendar.DAY_OF_MONTH));
// 这个月的第几周，从1开始算
System.out.println(c.get(Calendar.DAY_OF_WEEK_IN_MONTH));
// 这年的第几天，从1开始算
System.out.println(c.get(Calendar.DAY_OF_YEAR));
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

除了月份从0开始算，其它都是从1开始算，0月份=1月份，星期日是1。

注意：如果c.set(2021, 1, 0)，日期是0，相当于是第一个月

6、某一天是星期几

可以用基姆拉尔森公式：
(d + 2*m + 3*(m + 1)/5 + y + y / 4 - y / 100 + y / 400 + 1) % 7

• d 为日期，范围是1-31。
• m 为月份，范围是3-14，当年的1，2月需处理为上一年的13，14月。
• y为年份，当月份为1，2时，y需减一。
• 结果为0-6，星期日用0表示，星期一为1，以此类推，星期六为6。

更推荐的是用Calender类：

// 默认是当前日期
Calendar c = Calendar.getInstance();
// 星期日
c.set(2022, 2 - 1, 6);
// 返回给定的日期是星期几，注意“1”是代表星期日
System.out.println(c.get(Calendar.DAY_OF_WEEK));
1
2
3
4
5
6

7、计算时间间隔

主要是通过使用SimpleDateFormat，先把时间写成String，然后再转成Date， 用getTime函数转成毫秒，相减得到相差的毫秒数。注意1s = 1000ms，SimpleDateFormat中，HH代表24小时制，hh是12小时制，MM是月份，mm是分钟。

String start = "2021-7-13 13:14:20";
String end = "2021-7-10 13:14:20";
// 注意HH是24小时，hh是12小时
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date date1 = sdf.parse(start);
Date date2 = sdf.parse(end);
// 因为不知道谁大谁小，所以要用abs
long diff = Math.abs(date1.getTime() - date2.getTime());
System.out.println("相差" + diff + "毫米");
// 注意1s = 1000ms
long seconds = diff / 1000;
long minutes = diff / 1000 / 60;
long hours = diff / 1000 / 60 / 60;
long day = diff / 1000 / 60 / 60 / 24;
System.out.println(seconds + "秒");
System.out.println(minutes + "分钟");
System.out.println(hours + "小时");
System.out.println(day + "天");
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

8、四舍五入、向上（下）取整

8.1 四舍五入

很简单，利用int取整

double a = 4.7;
System.out.println((int)(4.2 + 0.5));
1
2

8.2 向上（下）取整

使用Math类的函数ceil（天花板，向上）和floor（地板，向下）实现

double a = 4.7;
System.out.println(Math.floor(a));
System.out.println(Math.ceil(a));
1
2
3

9、常用进制转换

1 B = 字节，1 b = 位，1个字节=8位，1KB = 1024B=2^10B（1024个字节），1MB = 1024 * 1024B = 2^20B字节，1GB = 1024 * 1MB = 2^30B字节。

1s = 1000ms = 1000000us = 1000000000ns

10、比赛中最大值和最小值的选取

在某些场合下java的Integer.MAX_VALUE在进行运算时会溢出，变为负值，所以防止溢出的问题，最大值一般采用：0x3f3f3f3f，最小值一般采用0xc0c0c0c0。都是四个重复：3f c0

11、质因数、因数

求一个数的约数个数，可以通过质因数分解，再求出其全部约数个数

1的约束个数=1，2的约数个数=2（1，2），3的约数个数=2（1，3），4 = 1 * 2 * 2 = 2^2，所以4的约数个数=3（1，2，4），5 = 1 * 5，其约数个数=2（1，5），注意这里求的约数个数都是不同的约数个数，并且每个约数都是正约数（>=1）。

注意，1不是质数，所以质因子就不可能有1，但是1是每个数的约数，约数中又有1。

求某个数的全部约数：

Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
for (int i = 1; i * i <= n; i++) {
	if (n % i == 0) {
		System.out.println(i);
		if (i != n / i) {
			System.out.println(n / i);
		}
	}
}
1
2
3
4
5
6
7
8
9
10

求某个数的全部质因子：

Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
for (int i = 2; i * i <= n; i++) {
	while (n % i == 0) {
		System.out.println(i);
		n /= i;
	}
	// 分解完了
	if (n == 1) break;
}
// 质数的情况
if (n != 1) {
	System.out.println(n);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

12、汉诺塔问题

import java.io.*;
import java.util.*;

public class Main {
    static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    static int num = 0;
    public static void main(String[] args) throws IOException {
    	hanoi(10, 'A', 'B', 'C');
    	System.out.println(num);
    }
    // 将编号为n的盘子，从a移动到b
    static void move(char a, int n, char b) {
    	num++;
    	System.out.println("第 " + num + " 次移动：" + "将" + n + "号盘子, 从 " + a + " 移动到 " + b);
    }
    // x:源 y:辅助 z:目的
    static void hanoi(int n, char x, char y, char z) {
    	if (n == 1) {
    		// 只有1号盘子（也就是最下面的盘子），把它从A柱移动到C柱即可
    		move(x, 1, z);
    	} else {
    		// 借助B柱，将A柱的n-1个盘子移到B柱
    		hanoi(n - 1, x, z, y);
    		// 将编号为n的盘子，从A柱移动到C柱
    		move(x, n, z);
    		// 借助A柱，将B柱的n-1个盘子移动到C柱
    		hanoi(n - 1, y, x, z);
    	}
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30