【Java程序设计竞赛常用知识点总结】
文章目录
- 1 数据类型
- 2 控制台的输入与输出
-
- 2.1 Scanner类
- 2.2 格式化输出
- 2.3 快读快写类
- 3 Math类
- 4 Calendar类
- 5 split()函数
- 7 switch语句
- 8 进制转换
1 数据类型
Java是一门强类型语言，这就意味着我们在编程时，每一个变量都需要声明指定的类型。在Java中，有8种原始的数据类型，分为4类，分别是整型、浮点型、字符型以及布尔型。具体来说：
-
整型（4种）：byte、int、short、long。这些类型主要用于表示整数。
-
浮点型（2种）：float、double。这些类型主要用于表示具有小数部分的数值。
-
字符型（1种）：char。这是一种特殊的数据类型，用于表示Unicode编码的字符单元。
-
布尔型（1种）：boolean。这种类型用于表示真（true）或假（false）。
下面是一个表格，详细解释了Java的各种基本数据类型的特性：
| 数据类型 | 对应的包装类 | 存储空间大小 | 位数 | 最小值 | 最大值 | 使用范围 |
|---|---|---|---|---|---|---|
| byte | Byte | 1 字节 | 8 位 | -128 | 127 | 可用于表示任何在-128到127之间的数字 |
| char | Character | 2 字节 | 16 位 | 0 | 65535 | 可用于表示任何在Unicode字符集中的字符 |
| short | Short | 2 字节 | 16 位 | -32768 | 32767 | 可用于表示任何在-32768到32767之间的数字 |
| int | Integer | 4 字节 | 32 位 | -2147483648 | 2147483647 | 可用于表示任何在约-20亿到20亿之间的数字 |
| long | Long | 8 字节 | 64 位 | -9223372036854775808 | 9223372036854775807 | 可用于表示任何在约-9e18到9e18之间的数字 |
| float | Float | 4 字节 | 32 位 | 1.4E-45 | 3.4028235E38 | 可用于表示任何在1.4E-45到3.4028235E38之间的数字 |
| double | Double | 8 字节 | 64 位 | 4.9E-324 | 1.7976931348623157E308 | 可用于表示任何在4.9E-324到1.7976931348623157E308之间的数字 |
这里我们要注意一下，3.4028347e+38这种形式的数字表示3.4028347乘以10的38次方。这是科学计数法的一种常见表示形式。
同时，我们也需要理解Java中的基本数据类型与对应包装类的主要区别：
| 相关面向 | 包装类 | 基本数据类型 |
|---|---|---|
| 数据的使用方式 | 作为对象使用，拥有自己的方法和字段，这些方法和字段都可以通过引用该对象的内存地址来调用。 | 基本数据类型没有方法和字段，它们不是对象。 |
| 数据的传递方式 | 引用传递，传递的是对象的内存地址，而非实际的值。 | 值传递，直接传递的是值本身。 |
| 内存的分配方式 | 需要用new关键字在堆内存中分配内存空间。 | 不需要new关键字，直接分配内存空间。 |
| 初始值 | 默认初始值为null。 | 除了char类型为’\u0000’或null，其他基本数据类型为0或false。 |
| 使用场景 | 主要在集合框架中使用，如ArrayList和HashMap等。 | 可以直接赋值使用，用于日常的值计算。 |
2 控制台的输入与输出
2.1 Scanner类
1）输入整数及一维整型数组
（1）输入测试要求：
输入两个整数m、n，接着再输入m个整数
（2）代码示例：
import java.util.Scanner;
public class Note {
public static void main(String[] args) throws Exception {
Scanner sc=new Scanner(System.in);
int m=sc.nextInt();
int n=sc.nextInt();
int[] arr=new int[m];
//读取数据存入字符串数组中，是否在同一行都可以读取（可以以空格或换行划分）
for(int i=0;i<m;i++) {
arr[i]=sc.nextInt();
}
System.out.println("m的值为："+m);
System.out.println("n的值为："+n);
System.out.print("输入的数组为：");
for(int i=0;i<m;i++) {
System.out.print(arr[i]+" ");
}
sc.close();
}
}
（3）输入示例及运行结果：
输入示例1：
3 4
1 2 3
运行结果1：
m的值为：3
n的值为：4
输入的数组为：1 2 3
输入示例2：
3
4
1 2 3
运行结果2：
m的值为：3
n的值为：4
输入的数组为：1 2 3
2）输入字符串及一维字符串数组
输入字符串有两种方式。一是使用next()；二是使用nextLine()，示例如下：
（1）输入测试要求：
第一行输入一行字符串（中间有空格），用next()读取
第二行输入一行字符串（中间有空格），用nextLine()读取
（2）代码示例：
import java.util.Scanner;
public class Note {
public static void main(String[] args) throws Exception {
Scanner sc=new Scanner(System.in);
//使用next()读取：读取输入直到遇到空白为止，读取后光标在本行
String str1=sc.next();
//将光标转移到下一行开始读取
sc.nextLine();
//使用nextLine()：读取除换行外的所有字符（包括空格），直到遇到换行为止，读取后光标在下一行
String str2=sc.nextLine();
System.out.println("用next()读取："+str1);
System.out.println("用nextLine()读取："+str2);
sc.close();
}
}
（3）输入示例及运行结果：
输入示例：
I love Java!
I love Java!
运行结果：
用next()读取：I
用nextLine()读取：I love Java!
关于next()和nextLine()的区别，下面我们重点说明：
-
next()：读取输入直到遇到空白为止。要注意以下几点：
-
必须要读到有效字符（除空格键、Tab键和Enter键等的无效字符是有效字符）才可以结束输入；
-
对有效字符之前的空格键、Tab键和Enter键等next()会自动将其去掉，只有在输入有效字符之后，next()方法才将其后输入的空格键和Enter键等视为结束符，因此next()方法不能得到带有空格符的字符串。
-
-
nextLine()：读取除换行外的所有字符（包括空格），直到遇到换行为止，读取后光标在下一行。要注意以下几点：
-
nextLine()方法并不要求必须读到有效字符才可以结束输入；
-
nextLine()的结束符只有Enter键，即nextLin()方法返回的是Enter键之前的所有字符，它是可以得到带有空格符的字符串的。
-
在同时使用next()方法和nextLine()方法时，常会出现以下问题，我们通过两个例子来说明：
（1）输入测试要求：
读取两个字符串（先用next()读取，再用nextLine()读取）
（2）代码示例：
import java.util.Scanner;
public class Note {
public static void main(String[] args) throws Exception {
Scanner sc=new Scanner(System.in);
//先用nextLine()读取，再使用next()读取
System.out.println("请输入第一个字符串：");
String str1=sc.nextLine();
System.out.println("请输入第二个字符串：");
String str2=sc.next();
System.out.println("str1为："+str1);
System.out.println("str2为："+str2);
sc.close();
}
}
（3）输入示例及运行结果：
输入示例：
请输入第一个字符串：
abc
请输入第二个字符串：
def
运行结果：
str1为：abc
str2为：def
由运行结果我们可以看到此时成功地实现了两个字符串的读取，再看下一个例子：
（1）输入测试要求：
读取两个字符串（先用next()读取，再用nextLine()读取）
（2）代码示例：
import java.util.Scanner;
public class Note {
public static void main(String[] args) throws Exception {
Scanner sc=new Scanner(System.in);
//先使用next()读取，再使用nextLine()读取
System.out.println("请输入第一个字符串：");
String str1=sc.next();
System.out.println("请输入第二个字符串：");
String str2=sc.nextLine();
System.out.println("str1为："+str1);
System.out.println("str2为："+str2);
sc.close();
}
}
（3）输入示例及运行结果：
输入示例：
请输入第一个字符串：
abc
请输入第二个字符串：(还没来的及输入就输出了下面的结果)
运行结果：
str1为：abc
str2为：
由运行结果我们发现当要输入第二个字符串时，还没有来得及输入就输出了下面的结果，经过尝试我们就可以发现当时用nextInt()、nextFlaot()和nextDouble()均会出现这个问题。原因是当使用next()读取完第一个字符串并赋值给str1后，nextLine方法开始读取本行中next()之后的内容并自动读取了Enter键作为结束符，此时赋值给str2的是空字符，解决方法是在next()方法与nextLine()方法之间再加一个nextLine()，如下：
（1）代码示例：
import java.util.Scanner;
public class Note {
public static void main(String[] args) throws Exception {
Scanner sc=new Scanner(System.in);
//解决方法是在next()方法与nextLine()方法之间再加一个nextLine()
System.out.println("请输入第一个字符串：");
String str1=sc.next();
sc.nextLine();
System.out.println("请输入第二个字符串：");
String str2=sc.nextLine();
System.out.println("str1为："+str1);
System.out.println("str2为："+str2);
sc.close();
}
}
（2）输入示例及运行结果：
输入示例：
请输入第一个字符串：
abc
请输入第二个字符串：
def
运行结果：
str1为：abc
str2为：def
由运行结果我们可知此时成功地读取了两个字符串。
输入一维字符串数组也有两种方式：一是使用for循环，一个一个地对数组元素进行赋值；二是使用split()函数对读取的一行字符串进行分割，将得到的字符串数组直接赋值给源字符串数组。示例如下：
（1）输入测试要求：
第一行输入一个整数，表示接下来要输入的两个字符串的长度
第二行输入一行字符串（中间有空格），使用for循环赋值给第一个字符串数组
第三行输入一行字符串（中间有空格），使用split()函数赋值给第二个字符串数组
（2）代码示例：
import java.util.Scanner;
public class Note {
//输出字符串数组函数
static void output(String[] arr) {
for(int i=0;i<arr.length;i++) {
System.out.print(arr[i]+" ");
}
}
public static void main(String[] args) throws Exception {
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
String[] arr1=new String[n];
//使用for循环，以空格进行分割进行读取，一个一个地对数组元素进行复制
for(int i=0;i<n;i++) {
arr1[i]=sc.next();
}
//将光标转移到下一行开始读取
sc.nextLine();
//先读取一行字符串，再以空格进行分割，将返回的字符串数组直接赋值给arr2
String[] arr2=sc.nextLine().split(" ");
System.out.print("使用for循环：");
output(arr1);
System.out.println();
System.out.print("使用split()分割：");
output(arr2);
sc.close();
}
}
（3）输入示例及运行结果：
输入示例：
5
a b c d e
a b c d e
运行结果：
使用for循环：a b c d e
使用split()分割：a b c d e
3）输入二维数组
输入二维数组可通过两层for循环实现。示例如下：
（1）输入测试要求：
第一行输入两个整数m、n，分别代表二维数组的行数和列数
第二行输入m*n个数，代表数组中的元素
（2）代码示例：
import java.util.Scanner;
public class Note {
static void output(int[][] arr,int m,int n) {
System.out.println("m的值为："+m);
System.out.println("n的值为："+n);
System.out.println("输入的数组为：");
for(int i=0;i<m;i++) {
for(int j=0;j<n;j++) {
System.out.print(arr[i][j]+" ");
}
System.out.println();
}
//直接通过arr拿到二维数组的行数和列数
System.out.println("数组的行数为："+arr.length);
System.out.println("数组的列数为："+arr[0].length);
}
public static void main(String[] args) throws Exception {
Scanner sc=new Scanner(System.in);
//定义m、n分别代表二维数组的行数和列数
int m,n;
m=sc.nextInt();
n=sc.nextInt();
int[][] arr=new int[m][n];
//使用两层for循环给二维数组赋值
for(int i=0;i<m;i++) {
for(int j=0;j<n;j++) {
arr[i][j]=sc.nextInt();
}
}
//调用自定义的output()函数输出结果
output(arr, m, n);
sc.close();
}
}
（3）输入示例及运行结果：
输入示例：
2 3
1 2 3 4 5 6
运行结果：
m的值为：2
n的值为：3
输入的数组为：
1 2 3
4 5 6
数组的行数为：2
数组的列数为：3
4）连续输入数字和字符串（根据输入决定停止时间）
有时我们并不知道输入的数据个数，这时就不能使用for循环进行读取。此时需要使用while(sc.hasNext())进行读取，来实现连续输入根据输入的数据来决定停止时间，示例如下：
（1）输入测试要求：
连续输入数字、空格、字符串或连续输入数字、换行、字符串
（2）代码示例：
import java.util.Scanner;
public class Note {
static void output(int n,String str) {
System.out.println("n的值为："+n);
System.out.println("str的值为："+str);
System.out.println("str的长度为："+str.length());
}
public static void main(String[] args) throws Exception {
Scanner sc=new Scanner(System.in);
while(sc.hasNext()) {
int n=sc.nextInt();
String str=sc.next();
output(n, str);
System.out.println();
}
sc.close();
}
}
（3）输入示例及运行结果：
输入示例1：
1 a 2 b 3 c 4 d
运行结果1：
n的值为：1
str的值为：a
str的长度为：1
n的值为：2
str的值为：b
str的长度为：1
n的值为：3
str的值为：c
str的长度为：1
n的值为：4
str的值为：d
str的长度为：1
输入示例2：
1
a
2
b
3
c
4
d
运行结果2：
n的值为：1
str的值为：a
str的长度为：1
n的值为：2
str的值为：b
str的长度为：1
n的值为：3
str的值为：c
str的长度为：1
n的值为：4
str的值为：d
str的长度为：1
如果要优化输入和输出，可参考下面的代码：
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.Scanner;
public class Note {
public static void main(String[] args) throws Exception {
//获取开始时间
long start=System.currentTimeMillis();
//原始
Scanner sc=new Scanner(System.in);
//优化输入
//Scanner sc=new Scanner(new BufferedReader(new InputStreamReader(System.in)));
//优化输出
//BufferedWriter out=new BufferedWriter(new OutputStreamWriter(System.out));
String[] arr=sc.nextLine().split(" ");
for(String s:arr) {
System.out.print(s+" ");
//使用out输出
//out.write(s+" ");
}
//一定要加，否则不会输出
//out.flush();
System.out.println();
sc.close();
long end=System.currentTimeMillis(); //获取结束时间
System.out.println("程序运行时间： "+(end-start)+"ms");
}
}
2.2 格式化输出
在Java中，主要有以下几种方式进行格式化输出：
-
使用
System.out.printf()方法：这种方式非常类似于C语言中的printf方法。 -
使用
String.format()方法：这种方式用于生成一个格式化的字符串，而不只是输出。
下面通过一个示例来详细说明如何进行格式化输出：
public class Main {
public static void main(String[] args) {
//定义几个变量用于格式化输出
String name = "张三";
int age = 25;
double height = 178.23;
//使用System.out.printf()进行格式化输出
//%s用于代表一个字符串，%d用于代表一个整数，%f用于代表一个浮点数
//\n代表换行
System.out.printf("我的名字是%s，年龄是%d岁，身高是%.2f厘米\n", name, age, height);
//使用String.format()生成一个格式化的字符串
//生成的字符串与上一次printf打印的结果一样
String formattedString = String.format("我的名字是%s，年龄是%d岁，身高是%.2f厘米\n", name, age, height);
System.out.println(formattedString);
}
}
在上述代码中，.2 代表保留两位小数，% 符号表示一个占位符，printf() 或 String.format() 方法会按照提供的顺序将后面的参数填充到占位符中。%s 用于替换字符串类型的值，%d 用于替换整数类型的值，%f 用于替换浮点数类型的值。
2.3 快读快写类
在使用Scanner和System.out进行输入输出时，速度较慢，可以使用下面的快读快写类来进行数据的输入与输出，如下：
package chapter1.KnowledgeSummary;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StreamTokenizer;
public class BufferedReaderAndPrintWriterSummary {
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
//初始化快读类、快写类
FastReader fastReader=new FastReader();
PrintWriter printWriter=new PrintWriter(new OutputStreamWriter(System.out));
//依次读取整数、长整型数、双精度浮点数、字符串
int num=fastReader.nextInt();
long num1=fastReader.nextLong();
double num2=fastReader.nextDouble();
String string =fastReader.nextLine();
//依次输出整数、长整型数、双精度浮点数、字符串
printWriter.println(num);
printWriter.println(num1);
printWriter.println(num2);
printWriter.print(string);
//循环读入数据，并输出累加和，因为循环不会停止，会抛出异常，但可以通过测试用例
// String line="";
// while ((line=fastReader.nextLine())!=null) {
// String[] strings=line.split(" +");
// int num3=Integer.parseInt(strings[0]);
// int num4=Integer.parseInt(strings[1]);
//
// printWriter.println(num3+num4);
// printWriter.flush();
// }
//注意后面一定要加printWriter.flush()
printWriter.flush();
//关闭fastReader和printWriter
fastReader.close();
printWriter.close();
}
}
//快读类FasterReader
class FastReader{
//FasterReader的两个属性：streaTokenzer（用于读取数字）和bufferedReader(用于读取字符串)
StreamTokenizer streamTokenizer;//译为流标记器
BufferedReader bufferedReader;//译为缓冲输入
//FasterReader的构造方法：用于初始化streamTokenizer和bufferedReader
public FastReader() {
// TODO Auto-generated constructor stub
streamTokenizer=new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
//System.in：读取字节流、InputStreamReader：将字节流->字符流、BufferedReader类从字符输入流中带缓存功能的读取字符
bufferedReader=new BufferedReader(new InputStreamReader(System.in));
}
//读取整数
int nextInt() throws IOException{
streamTokenizer.nextToken();
return (int) streamTokenizer.nval;
}
//读取长整型
long nextLong() throws IOException{
streamTokenizer.nextToken();
return (long) streamTokenizer.nval;//不能超过1e16，否则会造成精度丢失
}
//读取双浮点型
double nextDouble() throws IOException{
streamTokenizer.nextToken();
return streamTokenizer.nval;//streamTokenizer.nval读取的为double类型
}
//读取一行字符
String nextLine() throws IOException{
return bufferedReader.readLine();
}
//关闭bufferedReader
public void close() throws IOException {
bufferedReader.close();
}
}
//注意：不能将StreamTokenizer类和Scanner混用，容易出现问题
运行结果：
输入：
1
3678463988349
4.0
jejfguijoigj
输出：
1
3678463988349
4.0
jejfguijoigj
3 Math类
Math类中的常用的固定变量有：
（1）接近自然常数e的值：E
（2）接近圆周率的值：PI
Math类中的常用函数如下图：
代码示例：
System.out.println("对2.3向上取整的结果为："+Math.ceil(2.3));
System.out.println("对2.3向下取整的结果为："+Math.floor(2.3));
System.out.println("对2.3四舍五入取整的结果为："+Math.round(2.3));
System.out.println("对2.5四舍五入取整的结果为："+Math.round(2.5));
System.out.println(Math.pow(2, 3));//求2的3次方
System.out.println(Math.log(Math.E));//求自然常数e的自然对数
System.out.println(Math.log10(100));//求100以10为底的对数值
运行结果：
对2.3向上取整的结果为：3.0
对2.3向下取整的结果为：2.0
对2.3四舍五入取整的结果为：2
对2.5四舍五入取整的结果为：3
8.0
1.0
2.0
4 Calendar类
package chapter1.KnowledgeSummary;
import java.util.Calendar;
import java.util.Date;
public class CalendarClassSummary {
public static void main(String[] args) {
// TODO Auto-generated method stub
//1.Date类的简单介绍：
System.out.println("1.Date类的简单介绍：");
Date date=new Date();//创建一个Date对象
System.out.println(date);//输出date对象，默认调用toString()方法
System.out.println(date.getTime());//输出自1970年1月1日以来的毫秒数，返回值的数据类型为long
System.out.println();
//2.Calendar类的介绍：
System.out.println("2.Calendar类的介绍：");
/*（1）Calendar的常用属性：
* 1）YEAR：代表年份
* 2）MONTH：代表月份
* 3）DATE：代表日期，同DAY_OF_MONTH
* 4）DAY_OF_YEAR：这一天是这一年的第几天
* 5）DAY_OF_WEEK_IN_MONTH：当前月的第几周
* 6）DAY_OF_WEEK：一周中的第几天/星期
* 7）HOUR：12小时制的时间
* 8）HOUR_OF_DAY：24制的时间
* 9）MINUTE：分钟数
* 10）SECOND：秒数
* 11）MILLISECOND：毫秒
* */
//（2）Canlendar的常用方法：
//1）获取一个Calendar对象：
Calendar calendar=Calendar.getInstance();//使用getInstance()函数获取一个Calendar对象，默认为当前的时间
System.out.println(calendar.getTime());//使用getTime()方法获取一个当前时间的Date对象
//2）使用set设置时间：
//i）按照年月日来设置时间
calendar.set(2020, 5, 23);//设置时间为2020年6月23日（第二个参数0代表1月，……，11代表12月）
System.out.println(calendar.getTime());//输出设置的时间
//ii)按照字段来设置时间
calendar.set(Calendar.YEAR, 1999);//设置年份为1999年
calendar.set(Calendar.MONTH, 10);//设置月份为5月
calendar.set(Calendar.DATE, 26);//设置日期为20日
System.out.println(calendar.getTime());//输出设置的日期
//3）使用get来获取时间
//iii）按照字段获取相应的数据
System.out.println("年份："+calendar.get(Calendar.YEAR));
System.out.println("月份："+calendar.get(Calendar.MONTH));
System.out.println("日期："+calendar.get(Calendar.DATE));
System.out.println("这一天是该年的第几天："+calendar.get(Calendar.DAY_OF_YEAR));
System.out.println("日期"+calendar.get(Calendar.DAY_OF_MONTH));
System.out.println("今天是周几（周日为每周的第一天）："+calendar.get(Calendar.DAY_OF_WEEK));
System.out.println("这一天是今年的第几周（按照日历来算）："+Calendar.WEEK_OF_YEAR);
System.out.println("这个时间点的24小时制的时间："+calendar.get(Calendar.HOUR_OF_DAY));
System.out.println("今天是周几（周日为每周的第一天）："+calendar.get(Calendar.DAY_OF_WEEK));
System.out.println("这一天是当前月的第几周（即每月的1号是周一，2号是周二）："+calendar.get(Calendar.DAY_OF_WEEK_IN_MONTH));
System.out.println("这个时间点的12小时制的时间："+calendar.get(Calendar.HOUR));
System.out.println("这个时间点的24小时制的时间："+calendar.get(Calendar.HOUR_OF_DAY));
System.out.println("这个时间点的分钟数："+calendar.get(Calendar.MINUTE));
System.out.println("这个时间点的秒数："+calendar.get(Calendar.SECOND));
System.out.println("这个时间点的毫秒数："+calendar.get(Calendar.MILLISECOND));
System.out.println("该年的最小天数："+calendar.getActualMinimum(Calendar.DAY_OF_YEAR));
System.out.println("该月的最小天数："+calendar.getActualMinimum(Calendar.DAY_OF_MONTH));
System.out.println("该年的最大天数："+calendar.getActualMaximum(Calendar.DAY_OF_YEAR));
System.out.println("该月的最大天数："+calendar.getActualMaximum(Calendar.DAY_OF_MONTH));
//注意：在使用getActualMinimum()、getActualMaximum()方法时可能会出现一些问题，例如：
//输出的是2月的最后一天是31日
Calendar calendar2=Calendar.getInstance();
calendar2.set(Calendar.YEAR, 2017);
calendar2.set(Calendar.MONTH, 1);
System.out.println("2月第一天是："+calendar2.getActualMinimum(Calendar.DAY_OF_MONTH));
System.out.println("2月最后一天是："+calendar2.getActualMaximum(Calendar.DAY_OF_MONTH));
//原因：经测试，这个calendar还和当前天数有关，假如在1-28日基本都是没问题的，但到29-31日的时候，2月首先出现问题，之后就是日期为30号的月份也会出现问题。
//解决方法：在进行设置日期时，先清除一下缓存，或是设置一个日期为1号，如下：
//1.清除缓存
Calendar calendar3=Calendar.getInstance();
calendar3.clear();
calendar3.set(Calendar.YEAR, 2017);
calendar3.set(Calendar.MONTH, 1);
System.out.println("2月第一天是："+calendar3.getActualMinimum(Calendar.DAY_OF_MONTH));
System.out.println("2月最后一天是："+calendar3.getActualMaximum(Calendar.DAY_OF_MONTH));
//2.设置日期为1号
Calendar calendar4=Calendar.getInstance();
calendar4.set(Calendar.YEAR, 2017);
calendar4.set(Calendar.MONTH, 1);
calendar4.set(Calendar.DATE, 1);
System.out.println("2月第一天是："+calendar4.getActualMinimum(Calendar.DAY_OF_MONTH));
System.out.println("2月最后一天是："+calendar4.getActualMaximum(Calendar.DAY_OF_MONTH));
//总之，要记得每次设置日期前要使用clear()方法清除缓存或是设置日期为1号。
//4）使用add来时间使时间进行偏移（向前偏移或是向后偏移）
//i）向前偏移
calendar.clear();
calendar.set(2022, 2, 31);
while (calendar.get(Calendar.MONTH)!=1) {
System.out.println(calendar.getTime());
calendar.add(Calendar.DATE, -1);
}
//ii）向后偏移
calendar.clear();
calendar.set(2022, 1, 1);
while (calendar.get(Calendar.MONTH)!=2) {
System.out.println(calendar.getTime());
calendar.add(Calendar.DATE, 1);
}
//5）使用CompareTo(Calendar otherCalendar)来比较两个时间的先后
Calendar calendar5=Calendar.getInstance();
Calendar calendar6=Calendar.getInstance();
//i）若前者的时间更早，则返回-1
calendar5.clear();
calendar5.set(2020,1,3);
calendar6.clear();
calendar6.set(2020, 1,4);
System.out.println(calendar5.compareTo(calendar6));
//ii）若两者的时间相等，则返回0
calendar6.clear();
calendar6.set(2020,1,3);
System.out.println(calendar5.compareTo(calendar6));
//iii）若前者的时间更晚，则返回1
calendar6.clear();
calendar6.set(2020, 1, 2);
System.out.print(calendar5.compareTo(calendar6));
}
}
运行结果：
1.Date类的简单介绍：
Thu Jun 08 16:15:31 CST 2023
1686212131538
2.Calendar类的介绍：
Thu Jun 08 16:15:31 CST 2023
Tue Jun 23 16:15:31 CST 2020
Fri Nov 26 16:15:31 CST 1999
年份：1999
月份：10
日期：26
这一天是该年的第几天：330
日期26
今天是周几（周日为每周的第一天）：6
这一天是今年的第几周（按照日历来算）：3
这个时间点的24小时制的时间：16
今天是周几（周日为每周的第一天）：6
这一天是当前月的第几周（即每月的1号是周一，2号是周二）：4
这个时间点的12小时制的时间：4
这个时间点的24小时制的时间：16
这个时间点的分钟数：15
这个时间点的秒数：31
这个时间点的毫秒数：555
该年的最小天数：1
该月的最小天数：1
该年的最大天数：365
该月的最大天数：30
2月第一天是：1
2月最后一天是：28
2月第一天是：1
2月最后一天是：28
2月第一天是：1
2月最后一天是：28
Thu Mar 31 00:00:00 CST 2022
Wed Mar 30 00:00:00 CST 2022
Tue Mar 29 00:00:00 CST 2022
Mon Mar 28 00:00:00 CST 2022
Sun Mar 27 00:00:00 CST 2022
Sat Mar 26 00:00:00 CST 2022
Fri Mar 25 00:00:00 CST 2022
Thu Mar 24 00:00:00 CST 2022
Wed Mar 23 00:00:00 CST 2022
Tue Mar 22 00:00:00 CST 2022
Mon Mar 21 00:00:00 CST 2022
Sun Mar 20 00:00:00 CST 2022
Sat Mar 19 00:00:00 CST 2022
Fri Mar 18 00:00:00 CST 2022
Thu Mar 17 00:00:00 CST 2022
Wed Mar 16 00:00:00 CST 2022
Tue Mar 15 00:00:00 CST 2022
Mon Mar 14 00:00:00 CST 2022
Sun Mar 13 00:00:00 CST 2022
Sat Mar 12 00:00:00 CST 2022
Fri Mar 11 00:00:00 CST 2022
Thu Mar 10 00:00:00 CST 2022
Wed Mar 09 00:00:00 CST 2022
Tue Mar 08 00:00:00 CST 2022
Mon Mar 07 00:00:00 CST 2022
Sun Mar 06 00:00:00 CST 2022
Sat Mar 05 00:00:00 CST 2022
Fri Mar 04 00:00:00 CST 2022
Thu Mar 03 00:00:00 CST 2022
Wed Mar 02 00:00:00 CST 2022
Tue Mar 01 00:00:00 CST 2022
Tue Feb 01 00:00:00 CST 2022
Wed Feb 02 00:00:00 CST 2022
Thu Feb 03 00:00:00 CST 2022
Fri Feb 04 00:00:00 CST 2022
Sat Feb 05 00:00:00 CST 2022
Sun Feb 06 00:00:00 CST 2022
Mon Feb 07 00:00:00 CST 2022
Tue Feb 08 00:00:00 CST 2022
Wed Feb 09 00:00:00 CST 2022
Thu Feb 10 00:00:00 CST 2022
Fri Feb 11 00:00:00 CST 2022
Sat Feb 12 00:00:00 CST 2022
Sun Feb 13 00:00:00 CST 2022
Mon Feb 14 00:00:00 CST 2022
Tue Feb 15 00:00:00 CST 2022
Wed Feb 16 00:00:00 CST 2022
Thu Feb 17 00:00:00 CST 2022
Fri Feb 18 00:00:00 CST 2022
Sat Feb 19 00:00:00 CST 2022
Sun Feb 20 00:00:00 CST 2022
Mon Feb 21 00:00:00 CST 2022
Tue Feb 22 00:00:00 CST 2022
Wed Feb 23 00:00:00 CST 2022
Thu Feb 24 00:00:00 CST 2022
Fri Feb 25 00:00:00 CST 2022
Sat Feb 26 00:00:00 CST 2022
Sun Feb 27 00:00:00 CST 2022
Mon Feb 28 00:00:00 CST 2022
-1
0
1
5 split()函数
public class Note {
public static void main(String[] args) throws Exception {
/*split()函数：
* 该方法的参数含义：public String[](String regex)
* split()函数的作用：根据给定的正则表达式将字符串拆分为一个字符串数组
*
* 1.按照某一个字符分割；
* 2.以空白字符分割；
* 3.以多个空白字符分割；
* 4.用多个不同的字符来分割；
* 5.在分割时，需要转义的几个字符。
*/
//split(" ")表示以空格进行分割
String[] str1="a b c d,e".split(" ");//中间是一个Tab键
for(String s:str1) {
System.out.print(s+"-");
}
System.out.println();
//在正则表达式中，\\s表示空格、Tab键、回车、换行等空白字符
String[] str2="a b c d,e".split("\\s");//中间较大的空白是一个Tab键
for(String s:str2) {
System.out.print(s+"-");
}
System.out.println();
//在正则表达式中，+表示多个的意思，使用\\s+可以实现多个空白字符（>=1）分割的目的
String[] str3="a b c d,e".split("\\s+");//字符串中较大的空白第一个是两个空格，第二个是一个Tab键
for(String s:str3) {
System.out.print(s+"-");
}
System.out.println();
//使用多个不同的字符进行分割时，需要在各个字符中间加上|符号
String[] str4="abc%tgu$hyt@uit jit".split("%|$|@|\\s+");//字符串中较大的空白是两个空格
for(String s:str4) {
System.out.print(s+"-");
}
System.out.println();
//使用正则表达式时有些字符需要转义，转义时需要在在字符前加两个反斜杠，即\\，需要转义的字符有* . ? + ^ $ | \ [ ] ( ) { }
String[] str5="abc%tgu$hyt@uit jit".split("%|\\$|@|\\s+");//字符串中较大的空白是两个空格
for(String s:str5) {
System.out.print(s+"-");
}
}
}
运行结果：
a-b-c d,e-
a-b-c-d,e-
a-b-c-d,e-
abc-tgu$hyt-uit-jit-
abc-tgu-hyt-uit-jit-
6 equals和==的区别
package chapter1.KnowledgeSummary;
public class EqualsAndDoubleEqualSignDistinguishSummary {
public static void main(String[] args) {
// TODO Auto-generated method stub
//1.“==”和equals的区别：
System.out.println("1.“==”和equals的区别：");
/* “==”和equals的区别：
* （1）“==”：是运算符。如果是基本数据类型，则比较的是储存的值；如果比较的是引用数据类型，则比较的是所指向对象的地址值。
* （2）equals：是Object对象的方法，比较的是指向对象的地址值。一般情况下，若重写了equals方法，则比较的是对象的值，
* 如String类就重写了equals方法，使用equals方法比较的是字符串的值。
* */
//2.例子：
System.out.println("例子：");
//（1）例子1：
String string="abc";
String string2="abc";
System.out.println("==比较结果："+(string==string2));//输出：true。比较地址值：因为常量池中只有一个"abc"，所以它们的地址相同
System.out.println("equals比较结果："+(string.equals(string2)));//输出：true。比较内容：内容都为"abc"，内容相同
System.out.println();
//（2）例子2：
String string3=new String("def");
String string4=new String("def");
System.out.println("==比较结果："+(string3==string4));//输出：true。比较地址值：string3和string4在堆内存中的地址不同
System.out.print("equals比较结果："+(string3.equals(string4)));//输出：true。比较内容：内容都为"def"，内容相同
}
}
运行结果：
1.“==”和equals的区别：
例子：
==比较结果：true
equals比较结果：true
==比较结果：false
equals比较结果：true
7 switch语句
package chapter1.KnowledgeSummary;
public class SwitchSummary {
public static void main(String[] args) {
// TODO Auto-generated method stub
int key=0;
//switch语句：若不加break，在一条分支执行完后会依次判断下面的分支；若加上break，在一条分支执行完后会跳出判断
switch (key) {
case 0:
System.out.println(0);
key++;
break;
case 1:
System.out.println(1);
key++;
break;
case 2:
System.out.println(2);
break;
default:
System.out.println("default");
break;
}
}
}
运行结果：
0
8 进制转换
1.将十进制转换为n进制：
public class Try2 {
public static void main(String[] args) {
// TODO Auto-generated method stub
//将十进制转换n进制
int num=18;
System.out.println(Integer.toBinaryString(num));//将十进制转为二进制
System.out.println(Integer.toOctalString(num));//将十进制转换为八进制
System.out.println(Integer.toHexString(num));//将十进制转换为十六进制
System.out.print(Integer.toString(num,9));//将十进制转换为九进制（将十进制转换为n进制）
}
}
运行结果：
10010
22
12
20
2.将n进制转换为十进制：
public class Try2 {
public static void main(String[] args) {
// TODO Auto-generated method stub
//将n进制转换十进制
System.out.println(Integer.parseInt("1001", 2));//将(1001)2二进制数转为十进制，可以将n进制转换为十进制，只需改变后一个参数即可
}
}
运行结果：
9