蓝桥杯Java知识准备

已于 2022-01-24 19:18:48 修改
阅读量1.2w 收藏 246
点赞数 34
分类专栏： java 文章标签： 蓝桥杯 java 职场和发展
于 2022-01-24 19:16:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/triggerV/article/details/122673416
版权

1.输入输出

提到了几个IO类，这里推荐使用BufferedReader输入，BufferedWriter输出，当输入输出的数据量大于一百万左右就必须使用快速IO不能直接使用Scanne和System.out.print。

1.1 正常输入输出

输入

首先定义一个Scanner对象，需要导入包：import java.util.Scanner;

单个输入

import java.util.Scanner;

/**
 * @author wld
 * @date 2022/1/19 - 15:31
 */
public class LQ1_InputOutput {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int i = in.nextInt();
        double d = in.nextDouble();
        String s1 = in.next();      //String类型,遇到空格结束
        String s2 = in.nextLine(); //String类型,读取一行数据,遇到换行结束,类似gets
    }
}

多组输入：使用in.hasNext，返回值是bool值，作用是当在缓冲区内扫描到字符时，会返回true， 否则会发生阻塞，等待数据输入，所以in.hasNext()是不会返回false的。使用 while + in.hasNext() 相当于 while(scanf())。和in.nextXXX()方法类似，in.hasNextXXX()也有针对不同类型变量的方法。

class LQ2_InputOutput{
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        double a, b;
        int c;
        while (in.hasNext()){
            a = in.nextDouble();
            b = in.nextDouble();
            c = in.nextInt();
            System.out.println(a + b + c);
        }
        in.close();
    }
}

输出

  System.out.printf(); //和C/C++中的printf一样。 可使用格式控制符进行格式化输出。
  System.out.printf("%d",a);  // 例如： 输出一个int类型变量

  System.out.print();   //不能使用格式控制符进行格式化输出，仅输出变量

  System.out.println();  //不能使用格式控制符进行格式化输出，仅输出变量，但会自动输出一个换行。

1.2 快速输入输出

1.2.1 StreamTokenizer和PrintWriter

StreamTokenizer这种方式只能读取数字和字符串，不能读取空格和其他字符，不推荐。（如果输入除空格和回车以外的字符，会无法识别，显示成null。同时如果要求输出的是字符，你的输入是数字开头，则字符会变成null；要求是输入数字却输出字母，那么数字会变成0）

PrintWriter类中包含print()、printf()。printf()可用于格式化输出，但速度最慢，write()速度最快。

PS：在最后刷新输出缓冲区，要加上flush()，否则什么都输出不了。

1.2.2 BufferedReader和BufferedWriter

两个都在java.io.*包中。

BufferedReader
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));

int s1 = in.read(); //读入一个字符，可读入空格回车
String s2 = in.readLine(); //读入一行数据，可读入空格

PS：在windows中按一下回车一共有两个字符“\n\r”，因而要用**两个read()来吸收回车；而只需要一个readLine()**吸收回车。

BufferedWriter

主要使用write()类进行输出，会抛出异常。当数据量大的时候一定要使用这个类进行输出，输出后不会自动换行。

        BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));

write()不能直接输出int类型，会输出相应的ASCII码的字符。例如：输出65会显示A。当需要输出一个int变量时，可以使用Integer.toString(int a) 的方法，将其变成字符串形式输出；或者使用+拼接一个字符串。

2. 数组操作

2.1 数组的复制

2.1.1 数组的clone()

int[] a = {2, 3, 5, 11, 66, 86, 43, 89, 77, 21, 54, 31};
int[] b = new int[20];
b = a.clone();
System.out.println(Arrays.toString(b));
//[2, 3, 5, 11, 66, 86, 43, 89, 77, 21, 54, 31]

2.1.2 System.arraycopy()(重点)

public static void arraycopy(Object src, int srcPos, Object dest, int desPos, int length);//src是源数组，srcPos是源数组的起始下标，dest是目标数组，desPos是目标数组下标，length是复制的数组元素个数

PS：新的数组多余的位置自动补0，且比clone()速度快。

int[] a = {2, 3, 5, 11, 66, 86, 43, 89, 77, 21, 54, 31};
int[] b = new int[20];
System.arraycopy(a, 0, b, 0, 10);
System.out.println(Arrays.toString(b));
//[2, 3, 5, 11, 66, 86, 43, 89, 77, 21, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

System.arraycopy(a, 0, b, 0, a.length);
System.out.println(Arrays.toString(b));
//[2, 3, 5, 11, 66, 86, 43, 89, 77, 21, 54, 31, 0, 0, 0, 0, 0, 0, 0, 0]

2.1.3 Arrays类的copyOf()和copyOfRange()

copyOf()
public static int[] copyOf(int[] original, int newLength);
//int[]可以是基本类型，也可以是对象类型， original是源数组，newLength是新数组长度

PS：这个b数组的长度是下面的自己定义的长度15，而不像System.arraycopy()中的b长度是一开始定义的长度。

b = Arrays.copyOf(a, 5);
System.out.println(Arrays.toString(b));
//[2, 3, 5, 11, 66]

b = Arrays.copyOf(a, 15);
System.out.println(Arrays.toString(b));
//[2, 3, 5, 11, 66, 86, 43, 89, 77, 21, 54, 31, 0, 0, 0]
copyOfRange()
public static char[] copyOfRange(char[] original, int from, int to);
//char[]可以是基本类型，也可以是对象类型， original是源数组，from是指定复制元素在源数组的起始下标，to是结束下标，不包括

b = Arrays.copyOfRange(a, 2, 7);
System.out.println(Arrays.toString(b));
//[5, 11, 66, 86, 43]

2.2 数组相关操作

Arrays.fill(); //填充数组

int[] arr = new int[5];
Arrays.fill(arr, 4); //给所有值赋值为4
System.out.println(Arrays.toString(arr));
//[4, 4, 4, 4, 4]

Arrays.fill(arr, 1, 4, 7);
System.out.println(Arrays.toString(arr)); //[1,4)下标1开始，4结束不包括4，赋值为7
//[4, 7, 7, 7, 4]

Arrays.sort(); // 数组排序

int[] arr1 = {3, 5, 4, 1, 7};
Arrays.sort(arr1, 0, 3);
System.out.println(Arrays.toString(arr1));
//按小标0开始，3结束不包括3排序 [3, 4, 5, 1, 7]

Arrays.sort(arr1);
System.out.println(Arrays.toString(arr1));
//按数字从小到大 [1, 3, 4, 5, 7]

String[] arr2 = {"z", "a", "C"};
Arrays.sort(arr2);
System.out.println(Arrays.toString(arr2));
//按ASCII码从小到大 [C, a, z]

Arrays.sort(arr2, String.CASE_INSENSITIVE_ORDER);
System.out.println(Arrays.toString(arr2));
//按字母表顺序，忽略大小写 [a, C, z]

Arrays.sort(arr2, String.CASE_INSENSITIVE_ORDER);
Collections.reverse(Arrays.asList(arr2));
System.out.println(Arrays.toString(arr2));
//按字母表逆序，忽略大小写 [z, C, a]

Arrays.toString(); //将数组的内容全部打印出来

Arrays.equals(); //比较数组元素是否相等

Arrays.binarySearch(); //二分查找找指定元素的下标，数组一定要是排好序的，否则会出错。找到元素，只会返回最后一个位置。

数组容量如果不够用可以使用Arrays.copyOf()进行扩充。

3. 进制转换、保留小数

3.1 进制转换

十进制转其他进制

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

int k = 17;
int r = 2;
System.out.println(Integer.toString(k, r)); //转成r进制 10001

r = 8;
System.out.println(Integer.toString(k, r)); //转成r进制  21

r = 16;
System.out.println(Integer.toString(k, r)); //转成r进制  11

其他进制转换成十进制

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

System.out.println(Integer.parseInt("10001", 2)); //17
System.out.println(Integer.parseInt("21", 8)); //17
System.out.println(Integer.parseInt("11", 16)); //17

3.2 保留小数

函数：String.format()

double a = 121.4324654;
double b = 246.24098792;
System.out.println(String.format("%.2f", a)); //121.43
System.out.println(String.format("%.3f", b)); //246.241

4. 常用数据类型

4.1 byte

  • 8位
  • 最小值是-128(-2^7), 最大值是127(2^7 - 1)
  • 默认值为0

4.2 short

  • 16位
  • 最小值是-32768(-2^15), 最大值是32767(2^15 - 1)
  • 默认值为0

4.3 int

  • 32位
  • 最小值是-2^31, 最大值是2^31 - 1
  • 一般整型变量默认为int类型，默认值为0

4.4 long

  • 64位
  • 最小值是-2^63, 最大值是2^63 - 1
  • 默认值为0L

4.5 float

  • 32位，单精度
  • 默认值为0.0f

4.6 double

  • 64位，双精度
  • 浮点数的默认类型是double类型，默认值为0.0d

4.7 boolean

  • boolean数据类型表示一位的信息
  • 只有两个取值：true和false
  • 默认值为false

4.8 char

  • 16位
  • 最小值是‘\u0000’(即为0)，最大值是‘\uffff’(即为65535)

输入

单个字符

Scanner in = new Scanner(System.in);
char ch = in.next().charAt(3);  //wsldxa
System.out.println(ch); //d

字符数组

char[] chars = new char[20];
String s = in.next(); //wdksssa
chars = s.toCharArray();
System.out.println(chars); //wdksssa

输出

char[] chars = new char[20];
String s = in.next(); //wdksssa
chars = s.toCharArray();
System.out.println("s = :" + s); //s = :wdksssa
System.out.println("chars = :" + chars); //chars = :[C@7ea987ac
System.out.println(chars); //wdksssa

出现输出chars不同的结果是println方法的重载问题导致的。因为第一次中的"chars = :"把数组变成了String类型了，第一次调用的参数是String类型的，第二次调用的参数是char[]数组类型的。

4.9 基本数据类型与包装类

基本数据类型转换成包装类

int i = 77;
Integer in = new Integer(i);
System.out.println(in.toString());
Integer it = new Integer("12121"); //必须为数字的字符串，加字母会运行出错
System.out.println(it.toString());

包装类转换成基本数据类型

Integer integer = new Integer(17);
int a = integer.intValue();
System.out.println(a + 1); //18

基本数据类型、包装类转换成String

//方式一
int num = 12;
String s = num + "";
System.out.println(s); //12

//方式二
double d = 23.9;
String s1 = String.valueOf(d);
System.out.println(s1); //23.9

String转换成基本数据类型、包装类

String s = "21"; //只能写数字
int i = Integer.parseInt(s);
System.out.println(i + 1);

String s1 = "true"; //只有写true输出的才是true
boolean b = Boolean.parseBoolean(s1);
System.out.println(b);

自动装箱：基本数据类型转换成包装类；自动拆箱：包装类转换成基本数据类型。

4.10 String

字符串比较

  • 使用equals()比较内容是否一样(==比较的是地址)

  • 忽略大小写比较是equalsIgnoreCase()

  • 是否包含子串：contains()

    String s = "ascdkxkcc";
System.out.println(s.contains("as")); //true
System.out.println(s.contains("awww")); //false

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

    String s = "ascdkxkcc";
System.out.println(s.startsWith("asc")); //true
System.out.println(s.startsWith("asca")); //false

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

    String s = "ascdkxkcc";
System.out.println(s.endsWith("kcc")); //true
System.out.println(s.endsWith("kc")); //false

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

    String s = "ascdkxkcc";
System.out.println(s.indexOf("kcc")); //6
System.out.println(s.indexOf("kww")); //-1

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

    String s = "ascdkcxkcc";
System.out.println(s.lastIndexOf("sc")); //1
System.out.println(s.lastIndexOf("kc")); //7

  • 提取子串：substring()

    String s = "ascdkcxkcc";
System.out.println(s.substring(1)); //scdkcxkcc
System.out.println(s.substring(1, 5)); //从下标1到5(不包括5)，scdk

  • 去除首位空白字符

    • trim():去除字符串首尾空白字符，空白字符包括空格，\t, \r, \n
    • strip():和trim()不同的是中文的空格字符\u3000也会被移除

  • 判断字符串

    • 判断字符串是否为空：isEmpty()

      System.out.println("".isEmpty()); //true 字符串长度为0
System.out.println("  ".isEmpty());//false 字符串长度不为0

    • 判断字符串是否是空白字符串：isBlank()(只包含空白字符)

  • 替换：replace(),返回一个新字符串

    String s = "asedadssssse";
String s1 = s.replace('s', 'w');//单个字符换单个字符，不能单个字符换多个字符
String s2 = s.replace("da", "ww");
System.out.println(s1); //awedadwwwwwe
System.out.println(s2); //awedadwwwwwe

  • 分割字符串：split(), 返回是一个字符串数组

    String s = "ab,de,sffd";
String[] s1 = s.split(",");
for (int i = 0; i < s1.length; i++) {
    System.out.println(s1[i]);
}
//ab
//de
//sffd

String s2 = "ab\\sa\\svg\\ed";
String[] s3 = s2.split("\\\\"); //特殊情况,以\为分割线
for (int i = 0; i < s3.length; i++) {
    System.out.println(s3[i]);
}
//ab
//sa
//svg
//ed

//需要加双斜线的：+、*、$、^
String s4 = "av+sx+dj";
String[] s5 = s4.split("\\+"); //以+为分割线

//多个符号作为分隔符，使用多个分隔符则需要借助|符号
String s6 = "ab,dji+@sdji";
String[] s7 = s6.split(",|\\+|@"); //以, + @为分隔符

  • 拼接字符串：join(), 用指定的字符串连接字符串数组，返回一个字符串

    String s = "ab,de,sffd";
String[] s1 = s.split(",");
int len = s1.length;
for (int i = 0; i < len; i++) {
System.out.println(s1[i]);
}
String str = String.join("**", s1);
System.out.println(str); //ab**de**sffd
//ab
//de
//sffd

  • Integer有个getInteger(String)方法，它不是将字符串转换成int，而是把该字符串对应的系统变量转换成Integer。

    Integer.getInteger("java.version"); //版本号 11

  • 字符串与char[]数组相互转换

    new String(char[])是创建了一个新的String实例，并不会直接引用传入的char[]数组，因而修改外部的char[]不会影响String。

    char[] ch = "HelloJava".toCharArray(); //String ---> char[]
String s = new String(ch); //char[] ---> String

StringBuffer和StringBuilder

两者使用没什么区别，由于StringBuilder相较于StringBuffer有速度优势，所以多数情况下使用StringBuilder。

  • 字符串连接：append()

    StringBuilder strB = new StringBuilder();      System.out.println(strB.append("asa").append("seewaa")); //asaseewaa

  • 将第i个代码单元设置成c(理解成替换)：setCharAt(int i, char c)

    strB.setCharAt(2, 'g');
System.out.println(strB); //asgseewaa

  • 在指定位置之前插入字符(串):insert(int offset, String s) / insert(int offset, char c)

    System.out.println(strB.insert(2, "wld")); //aswldaseewaa

  • 删除起始位置(含)到结尾位置(不含)之间的字符串：delete (int startIndex, int endIndex)

    System.out.println(strB.delete(1, 4)); //aeewaa

String与StringBuilder相互转换

String s = "seesaw";
StringBuilder sb = new StringBuilder(s); //String ---> StringBuilder
String ss = sb.toString(); //StringBuilder ---> String
System.out.println(ss);

使用基本原则

  • 操作少量数据：String
  • 单线程操作大量数据：StringBuilder
  • 多线程操作大量数据：StringBuffer

在使用StringBuffer类时，每次都会对对象本身进行操作，而不是生成新的对象，所以在需要对字符串进行修改推荐使用StringBuffer。StringBuilder不是线程安全的(不能同步访问)，但有速度优势。

length()、length属性、size()区别

  • length()是针对字符串来说的。
  • length属性是针对数组来说的。
  • size()是针对泛型集合来说的。

5. 位运算

  • 按位取反(~)：将0变1，1变0
  • 按位与(&)：同时为1才为1，否则为0
  • 按位异或(^)：不同为1，相同为0 (任何数与0异或都是它本身)
  • 按位或(|)：只要有1结果就是1，否则为0

在计算机中，整数是按原码存放的，负数是按补码存放的。整数的补码和原码相同，负数的补码等于原码取反后再加1。

位运算的技巧

  • 交换两数

    int a = 121;
int b = 343;
a = a ^ b;
b = a ^ b;
a = a ^ b;
//两个相同的数异或之后结果是0，任何数与0异或是它本身。
//异或运算支持交换律和结合律

  • 找出没有重复的数：给出一组整形数据，这些数据中有一个数只出现了一次，让找出这个数。

    public static int find(int[] arr){
    /*int temp = arr[0];
        for (int i = 1; i < arr.length; i++) {
            temp = temp ^ arr[i];
        }
        return temp;*/
    int x = 0;
    for(int i : arr){
        x = x ^ i;
    }
    return x;
}
//相同的数异或是0，0和任何数异或是它本身

  • 求两个数的平均值

    (a & b) + ((a ^ b) >> 1)
//防止两数相加超出类型范围

  • 判断一个数是否是2的整数次幂

    int n = 1024;
//方法一：
if((n & (n - 1)) == 0){
System.out.println("YES");
}else{
System.out.println("NO");
}
//如果是负数和0要单独判断

//方法二：
if((n & (-n)) == n){
    System.out.println("YES");
}else{
System.out.println("NO");
}

  • 消除二进制中的最后一个1

    n & (n - 1)

6. 大数处理

整数用BigInteger，小数用BigDecimal。

BigInteger常用方法

  • 求绝对值abs()

    String s = "-32542357682";
BigInteger big = new BigInteger(s);
BigInteger bigs = big.abs();
System.out.println(bigs); //32542357682

  • 两数相加add()

    String s = "-3848432939";
String ss = "7959532028";
BigInteger bs = new BigInteger(s);
BigInteger bss = new BigInteger(ss);
BigInteger add = bs.add(bss);
System.out.println(add); //4111099089

  • 两数相减substract()

  • 两数相乘multiply()

  • 两数相除divide()

  • 求相反数negate()

  • 求余数remainder() (在小数中可以使用)

  • 求模mod() (不能在小数中使用)

  • 求幂次方pow()

  • 返回大整数的double值doubleValue() (也有类型对应：floatValue、intValue、longValue)

    String s = "357425778";
String ss = "34546";
BigInteger bs = new BigInteger(s);
BigInteger bss = new BigInteger(ss);
double d = bs.doubleValue();
double dd = bss.doubleValue();
System.out.println(d); //3.57425778E8
//当数组长度超过7位，会自动采用科学计数法输出
System.out.println(dd); //34546.0

  • 两数中的最大值max()

  • 两数中的最小值min()

  • 求两数的最大公约数gcd()

  • 两数的按位与and()

  • 两数的按位或or()

  • 两数的异或xor()

  • 将当前数左移n位shiftLeft()：当前数乘以n个2

  • 将当前数右移n位rightLeft()：当前数除以n个2

BigInteger进制转换

十进制转其他进制

String string1 = new BigInteger("20", 10).toString(2);
System.out.println("十进制的20转换成二进制是："+string1);

String string2 = new BigInteger("20", 10).toString(8);
System.out.println("十进制的20转换成八进制是："+string2);

String string3 = new BigInteger("20", 10).toString(16);
System.out.println("十进制的20转换成十六进制是："+string3);

//十进制的20转换成二进制是：10100
//十进制的20转换成八进制是：24
//十进制的20转换成十六进制是：14

其他进制转换十进制

String string4 = new BigInteger("110", 2).toString(10);
System.out.println("二进制的110转换成十进制是："+string4);

String string5 = new BigInteger("110", 8).toString(10);
System.out.println("八进制的110转换成十进制是："+string5);

String string6 = new BigInteger("110", 16).toString(10);
System.out.println("十六进制的110转换成十进制是："+string6);

//二进制的110转换成十进制是：6
//八进制的110转换成十进制是：72
//十六进制的110转换成十进制是：272

BigDecimal

小数位数

Scanner cin = new Scanner(System.in);
BigDecimal big ;
big = cin.nextBigDecimal();
System.out.println(big.scale()); //scale() 获取小数位数；若是整数则为负数，表示的末尾的0个数
System.out.println(big);
big = big.stripTrailingZeros(); // 去掉小数末尾的无用0
System.out.println(big.scale());
System.out.println(big);

对一个BigDecimal设置它的scale，如果精度比原始值低，那么按照指定的方法进行四舍五入或者直接截断。

BigDecimal d1 = new BigDecimal("123.456789");
BigDecimal d2 = d1.setScale(4, RoundingMode.HALF_UP); // 四舍五入
BigDecimal d3 = d1.setScale(4, RoundingMode.DOWN); // 直接截断
System.out.println(d2); //123.4568
System.out.println(d3); //123.4567

对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，因为除不尽

对BigDecimal做除法的同时求余数。调用divideAndRemainder()方法时，返回的数组包含两个BigDecimal，分别是商和余数，其中商总是整数，余数不会大于除数。

BigDecimal n = new BigDecimal("12.345");
BigDecimal m = new BigDecimal("0.12");
BigDecimal[] dr = n.divideAndRemainder(m);
System.out.println(dr[0]); // 102
System.out.println(dr[1]); // 0.105

在比较两个BigDecimal的值是否相等时，要特别注意，使用equals()方法不但要求两个BigDecimal的值相等，还要求它们的scale()相等。
必须使用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

7.日期时间

Date类

使用当前的日期和时间来初始化对象。

Date date = new Date();
System.out.println(date);

接收一个参数，该参数是从1970.1.1起的毫秒数

Date date = new Date(10000000);
System.out.println(date);

1.日期比较

Java使用以下三种方法来比较两个日期：

  • 使用getTime()来获取两个日期，然后比较这两个值。
  • 使用before()、after()、equals()。
  • 使用compare To()，它是由Comparable接口定义的，Date实现了这个接口。

2.日期和时间的格式化编码

使用SimpleDateFormat格式化日期，它允许你选择任何用户自定义日期时间格式来运行。

Date date = new Date(120000000);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
System.out.println(sdf.format(date)); //1970-01-02 17:20:00

SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss");
System.out.println(sdf2.format(date)); //1970年01月02日 17时20分00

ps：有的格式大写，有的格式小写。例如：MM是月份，mm是分；HH是24小时制，hh是12小时制。

3.System类中的currentTimeMillis()

返回一个long型的数值，这个数值是当下时间与1970.1.1零时的时间差，以毫秒为单位。

long t = System.currentTimeMillis();
System.out.println(t);

4.printf格式化日期

使用两个字母格式，它以%t开头并且以下面中的一个字母结尾。

Date date = new Date();
//c的使用： 全部日期和时间信息：星期一 一月 24 17:41:02 CST 2022
System.out.printf("全部日期和时间信息：%tc%n" ,date);
//f的使用： 年-月-日格式：2022-01-24
System.out.printf("年-月-日格式：%tF%n" ,date);
//d的使用： 月/日/年格式：01/24/22
System.out.printf("月/日/年格式：%tD%n" ,date);
//r的使用： HH:MM:SS PM格式（12时制）：05:41:02 下午
System.out.printf("HH:MM:SS PM格式（12时制）：%tr%n" ,date);
//t的使用： HH:MM:SS格式（24时制）：17:41:02
System.out.printf("HH:MM:SS格式（24时制）：%tT%n" ,date);
//R的使用： HH:MM格式（24时制）：17:41
System.out.printf("HH:MM格式（24时制）：%tR" ,date);

5.字符串转换成时间

SimpleDateFormat 类有一些附加的方法，特别是parse()，它试图按照给定的SimpleDateFormat 对象的格式化存储来解析字符串。format()将Date对象格式化为字符串。

String s = "2022年1月24日";
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");//用来解析字符串
Date date = null;
try {
date = sdf.parse(s);
} catch (ParseException e) {
e.printStackTrace();
}
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy/MM/dd"); //按照格式输出时间字符串
System.out.printf(sdf2.format(date)); //2022/01/24

Calendar类

抽象类，可以设置(加减)和获取日期数据的特定部分。

Calendar的月份是从0开始的，但日期和年份是从1开始的。周日–周六对应1–7.

1.创建对象

当前日期的Calendar对象

Calendar c = Calendar.getInstance();//默认是当前日期,创建一个代表系统当前日期的Calendar对象

指定日期的Calendar对象：先创建对象，再设定该对象的年月日参数来完成。

//创建一个代表2022年1月24日的Calendar对象
Calendar c1 = Calendar.getInstance();
c1.set(2022, 1 - 1, 24);

2.信息的设置

  • set(int year, int month, int date)
c1.set(2022 ,1, 24);//把Calendar对象c1的年月日分别设这为:2022、1、24
c1.set(Calendar.DATE, 10);//把 c1对象代表的日期设置为10号，其它所有的数值会被重新计算

  • add()

    c1.add(Calendar.DATE, 10);
//把c1对象的日期加上10，也就是c1也就表示为10天后的日期，其它所有的数值会被重新计算

  • get()

    Calendar c1 = Calendar.getInstance();
// 获得年份
int year = c1.get(Calendar.YEAR);
// 获得月份
int month = c1.get(Calendar.MONTH) + 1; //因为是从0开始的，所以要加1
// 获得日期
int date = c1.get(Calendar.DATE);
// 获得小时
int hour = c1.get(Calendar.HOUR_OF_DAY);
// 获得分钟
int minute = c1.get(Calendar.MINUTE);
// 获得秒
int second = c1.get(Calendar.SECOND);
// 获得星期几（注意（这个与Date类是不同的）：1代表星期日、2代表星期1、3代表星期二，以此类推）
int day = c1.get(Calendar.DAY_OF_WEEK);

求两个时间间隔

    public static long getStartToEndTime(String start,String end) throws Exception{
        String startTime = start;
        String endTime = end;
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); //时间格式根据需要变动
        Date d1 = format.parse(startTime);
        Date d2 = format.parse(endTime);
        long diff = Math.abs(d1.getTime() - d2.getTime());
        
        System.out.println("相差 " + diff + " 毫秒");
        long diffSeconds = diff / 1000 % 60; //秒
        long diffMinutes = diff / (60 * 1000) % 60; //分钟
        long diffHours = diff / (60 * 60 * 1000) % 24; //小时
        long diffDays = diff / (24 * 60 * 60 * 1000); //天
        System.out.print("两个时间相差：");
        System.out.print(diffDays + " 天, ");
        System.out.print(diffHours + " 小时, ");
        System.out.print(diffMinutes + " 分钟, ");
        System.out.println(diffSeconds + " 秒.");
        System.out.println("相差 " + diffDays / 365 + " 年");
        return diff;
    }

求日期的天数、周数、星期数

ps：这里的第几周不是按平常的一周七天计算的，是按照日历中的一行来算的。

Date date = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒SSS毫秒");
System.out.println(sdf.format(date));
SimpleDateFormat sdf2 = new SimpleDateFormat("E 一年中的第w周、第D天 一个月中的第W周的周F 一天中的24制的第k小时（点）12制的第K小时（点）");
System.out.println(sdf2.format(date));
//2022年01月24日 19时09分00秒489毫秒
//星期一 一年中的第5周、第24天 一个月中的第5周的周4 一天中的24制的第19小时（点）12制的第7小时（点）
ZoeLandia
关注
专栏目录
第十三届蓝桥杯Java C组试题
04-09
【标题】"第十三届蓝桥杯Java C组试题"涵盖了两个主要编程语言——Java和C，在这个竞赛中，参赛者需要展示他们在编程、算法设计和问题解决上的技能。蓝桥杯是一项全国性的软件和信息技术专业人才大赛，旨在促进高校...
2018第九届蓝桥杯Java语言C组&答案（无第十题）
04-18
在准备蓝桥杯Java语言竞赛时，考生需要掌握以下几个关键知识点： 1. **基础语法**：包括数据类型、变量、运算符、控制结构（如if语句、for循环、while循环）、函数等Java的基础知识。 2. **面向对象编程**：理解类...
蓝桥杯Java B组的赛前准备
weixin_53195537的博客
03-18 6926
必备知识：基础数学知识，java语言的熟悉，搜索，模拟，Java容器类 怎么说呢，数学知识对算法有多重要就不说了。而java语言的熟悉这个就更不用说了吧。 至于模拟，相信在网上搜关于蓝桥杯的相关信息时， ...
蓝桥杯准备之路-Java基础复习
qq_62609093的博客
01-20 805
java基础复习
Java蓝桥杯备考---1.语言基础
m0_75120337的博客
02-07 1365
掌握蓝桥杯所需要的java语言基础
蓝桥杯大赛java组准备_蓝桥杯大赛java组算法类冲刺第一天
weixin_33709522的博客
02-28 535
算法：如果给定N个不同字符，将这N个字符全排列，最终的结果将会是N！种。如：给定ABC三个不同字符，则结果为：3！=3*2=6种情况代码实现import java.util.Scanner;import java.util.Vector;public class Main02 {public static long count=0;private void fullPermutation(Vect...
蓝桥杯Java语言A组真题
07-22
在“蓝桥杯Java语言A组真题”中，参赛者会遇到一系列精心设计的编程问题，这些问题涵盖了Java的基础知识、数据结构、算法等多个方面。下面我们将详细探讨这些知识点。 首先，基础语法是Java学习的基石，包括变量、...
蓝桥杯历届真题解析（Java 大学 A,B,C 组）
03-26
《蓝桥杯历届真题解析（Java 大学 A,B,C 组）》是一部集成了历年蓝桥杯编程竞赛中Java大学组A、B、C三类问题的解析资料，旨在帮助参赛者深入理解比赛题目，提升编程技能，以及为准备参加蓝桥杯的大学生提供宝贵的...
第十五届蓝桥杯java b组
最新发布
04-14
### 第十五届蓝桥杯Java B组知识点解析 #### 一、比赛背景与形式 第十五届蓝桥杯Java B组比赛是一项针对具有一定Java编程基础的学生进行的技术竞赛。该比赛旨在通过一系列精心设计的编程挑战，全面评估参赛者在...
蓝桥杯Java竞赛指导书
11-15
蓝桥杯 Java 前言 1 第1章 使用说明 2 1.1指导思想与目标定位 2 1.2总体安排 2 1.3活动方式 3 1.4实验室软硬件环境要求 3 第一阶段 动员报名 2-3章（11月份第1个周日，1次） 5 第2章 大赛介绍、参赛及准备方法 5 2.1大赛介绍 5 2.2参赛及准备方法 6 2.3大赛环境调试与项目、包、主类定义 6 第3章 题型、考点趋势及应对策略 10 3.1 题型、评分介绍 10 3.2 预赛题型趋势及应对策略 11
蓝桥杯大赛培训Java组
10-14
蓝桥杯大赛培训Java组
蓝桥杯Java组备赛（比赛环境：eclipse安装配置，hello world运行，常规操作配置）
jungleirim的博客
01-23 6293
相较于idea，eclipse需要自己配置一些常规操作，以便于适应编程习惯，提高我们的代码编写速度。2.修改内容辅助（content assist）中的字符为。下载之后解压到文件夹中，直接运行exe文件即可。其他与idea大致相同，这里就不过多赘述了。默认下一步，之后看到主界面。但要关闭windows10。依旧是进入窗口中的偏好设置。4.复制代码到上/下行。生成主函数，填写类名。
【蓝桥杯】Java组必备API类 --高精大数类 BigInteger BigDecimal总结
qq_48596586的博客
03-24 2348
大数类 大数类一共有两个，分别是BigInteger和BigDecimal，大数整形变量以及大数浮点数，理论上可以存储无线长的数字（只要你计算机的内存足够），接下来我将会分别介绍这两个类。 BigInteger 构造函数 BigInteger一共有六个构造方法，分别是以下六个，个人认为最常用的应该是第五个将字符串转换为BigInteger。 BigInteger b = BigInteger(byte[] val) //将包含BigInteger的二进制补码二进制表达式的字节数组转换为BigIntege.
蓝桥杯JavaB组应该怎么准备
weixin_35749545的博客
02-11 512
蓝桥杯JavaB组的准备工作非常重要，要想取得好成绩，首先要掌握JavaB组的基础知识，包括Java语言的基础语法、类、对象、接口、异常处理、集合框架等等，还要了解和掌握相关的算法、数据结构、操作系统、计算机网络等知识；其次，要多做练习，熟悉相关的编程题，熟练掌握编程技巧；最后，要重视考试的时间安排，多做一些模拟考试，提高自己的考试能力。 ...
蓝桥杯比赛准备之开篇
hailei1的博客
03-30 740
蓝桥杯准备之开篇 在享受了那么多天的疫情宅家生活，我终于克服了我的拖延症（不，它一直存在，只不过我再不准备我就死了），开始我的蓝桥杯java B组比赛的准备，同时也在此记录下我的每份努力。首先我先说明一下我的情况，我是一个很菜的小白，但是！我有梦想（赚大钱！os:太俗了吧），大二上学期学了java课程，那时就对java语言挺感兴趣的，最后还做了个分形集合的课设（如下图），取得了班级课设的最高分，这...
2018蓝桥杯省赛JAVA组
loftrina的博客
04-01 4248
有些题还不会做，有些题还没来得及上代码，先把题目写下来再说（比较抽象）题目1：小明第一天得到一块钱，每天比昨天多得到两块钱，第几天攒够108？题目2：猴子数香蕉一个数，分成五份去掉多余的四个再去掉五分之一，然后分成五份去掉多余的三个再去掉五分之一，然后分成五份去掉多余的两个再去掉五分之一，然后分成五份去掉多余的一个再去掉五分之一，然后正好被五整除，这个数最小多少？题目3：幸运数字某个14位数是第几...
我的蓝桥杯的准备
qq_38827988的博客
03-28 1220
为蓝桥杯省赛准备的两把98K1.穷举法2.递归法为蓝桥杯省赛准备的吉普车Java集合API为蓝桥杯省赛准备的三级套前辈心得最后:大吉大利,今晚吃鸡
Java在算法竞赛中的技巧（蓝桥杯备赛总结）
weixin_52161359的博客
05-29 8329
前言：笔者在这段时间准备蓝桥杯竞赛，由于个人原因选择Java作为语言，刷题中也是不断感到Java有些语法还是不够方便（非常羡慕隔壁C++的STL…），不过有些常见的技巧/方法/模板，也是自己做了些总结，十分之不全面，比完赛会继续完善… ！！！！！提交结果时记得检查有无不该加的头文件，主类名是否为Main！！！！！！ 2.优化输入输出时间（快速IO模板）： import java.io.*; import java.math.BigDecimal; import java.math.BigInteger
蓝桥杯java准备路线
10-16
好的，针对蓝桥杯Java的准备路线，我给您提供以下建议： 1. 熟悉Java基础知识，包括语法、面向对象编程、集合框架等。 2. 学习算法和数据结构，这是蓝桥杯考试的重点，需要掌握常见的算法和数据结构，如排序、查找、树、图等。 3. 练习编程，多做一些蓝桥杯历年真题和模拟题，熟悉考试的题型和难度。 4. 参加一些比赛，可以提高自己的编程能力和应试能力。
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值