目录
正则表达式
1、正则表达式的概述：是指一个用来描述或者匹配一系列符合某个语法规则的字符串的单个字符串。其实就是一种规则。有自己特殊的应用。
2、正则表达式作用：比如注册邮箱，邮箱有用户名和密码，一般会对其限制长度，这个限制长度的事情就是正则表达式做的。
3、判断给定字符串与正则表达式是否匹配：
String中matches(String regex)：告知此字符串是否匹配给定的正则表达式。返回值类型boolean。
格式：字符串.maches(regex); regex为设定的正则表达式名。
4、正则表达式中的字符类：[]代表单个字符。使用方法：String regex = "[abc]";直接将正则表达式写在""内即可。
| [abc] | a、b 或 c（简单类）。 |
| [^abc] | 任何字符，除了 a、b 或 c（否定） 取反的意思。 |
| [a-zA-Z] | a到 z 或 A到 Z，两头的字母包括在内（范围）（并集）。 |
| [a-d[m-p]] | a到d或m到p：[a-dm-p]（并集）。 |
| [a-z&&[def]] | d、e或f（交集） 跟直接写[def]一样。 |
| [a-z&&[^bc]] | a到z，除了b和c：[ad-z]（减去） 相当于前半部分规定范围，后半部分除去bc。 |
| [a-z&&[^m-p]] | a到z，而非m到p：[a-lq-z]（减去）规定大范围，除去一个子范围。 |
| [0-9] | 0到9的字符都包括。 |
5、预定义字符类 ：格式：String regex = "..";两个点就代表两个任意字符。所有\开头的预定义字符串，都需要都打一个\。
| . | 任何字符。 |
| \d | 数字：[0-9] \d代表转义字符，如果想表示\d的话，需要\\d。 |
| \D | 非数字：[^0-9] 除了0-9其他单个字符都是可以的。 |
| \s | 空白字符：[ \t\n\x0B\f\r] 中括号中开头有个空格。空格水平制表符换行\x0B垂直制表符翻页回车 注意：四个空格虽然和tab键长度一样，但 是四个字符。 |
| \S | 非空白字符：[^\s]。 |
| \w | 单词字符：[a-zA-Z_0-9]。 |
| \W | 非单词字符：[^\w]。 |
6、Greedy 数量词： X指的是一组，次数为[]中所有单个字符出现的总次数。
| X? | X，一次或一次也没有。 格式：String regex = "[abc]?"; 一次也没有指的是""中无内容，返回的也是true。如果是其他无关字符，返回false。 |
| X* | X，零次或多次。一次也包括。零次等于一次也没有。 |
| X+ | X，一次或多次。 |
| X{n} | X，恰好 n 次。 |
| X{n,} | X，至少 n 次。 |
| X{n,m} | X，至少 n 次，但是不超过 m 次。 |
7、正则表达式的分割功能：
String类的功能：public String[] split(String regex)。根据给定正则表达式的匹配拆分此字符串，并生成一个字符串数组。
格式：String[] 数组名 = 字符串变量名.split(" ");用空格分割。用什么""内就写什么。
注意：.代表任意字符，啥都匹配。非要用点切，得转义，用\\.。\.代表正则里的.。
8、案例演示：把给定字符串中的数字排序。
import java.util.Arrays;
/**
* 需求：我有如下一个字符串:”91 27 46 38 50”，请写代码实现最终输出结果是：”27 38 46 50 91”
* 分析：
* 1、将字符串切割成字符串数组。
* 2、将字符串转换成数字并将其存储在一个等长度的int数组中。
* 3、排序。
* 4、将排序后的结果遍历并拼接成一个字符串。
*/
public class Test1 {
public static void main(String[] args) {
String s = "91 27 46 38 50";
//1、将字符串切割成字符串数组。
String[] sArr = s.split(" ");
//2、将字符串转换成数字并将其存储在一个等长度的int数组中。
int[] arr = new int[sArr.length];
for (int i = 0; i < arr.length; i++) {
arr[i] = Integer.parseInt(sArr[i]); //将数字字符串转换成数字。
}
//3、排序。
Arrays.sort(arr);
//4、将排序后的结果遍历并拼接成一个字符串27 38 46 50 91。
//用String拼接会产生很多垃圾。
/*String str = "";
for (int i = 0; i < arr.length; i++) {
if(i == arr.length - 1) {
str = str + arr[i]; //27 38 46 50 91
}else {
str = str + arr[i] + " "; //27 38 46 50
}
}
System.out.println(str);*/
StringBuilder sb = new StringBuilder();
for (int i = 0; i < arr.length; i++) {
if(i == arr.length - 1) {
sb.append(arr[i]); //27 38 46 50 91
}else {
sb.append(arr[i] + " "); //27 38 46 50
}
}
System.out.println(sb); //打印默认调用toString()
}
}
9、正则表达式的替换功能：
String类的功能：public String replaceAll(String regex,String replacement)。想用什么替换，replacement就传什么。
10、正则表达式的分组功能：
捕获组可以通过从左到右计算其开括号来编号。例如，在表达式 ((A)(B(C))) 中，存在四个这样的组：
| 1组 | ((A)(B(C))) |
| 2组 | (A |
| 3组 | (B(C)) |
| 4组 | (C) |
组零始终代表整个表达式。
11、案例演示：
叠词AABB：
String regex = "(.)\\1(.)\\2"; \\1代表第一组又出现一次。 \\2代表第二组又出现一次。叠词ABAB：
String regex2 = "(..)\\1";
System.out.println("ABAB".matches(regex2));切割：
需求：请按照叠词切割： "sdqqfgkkkhjppppkl";
public static void main(String[] args) {
//切割：需求：请按照叠词切割： "sdqqfgkkkhjppppkl";
String s = "sdqqfgkkkhjppppkl";
String regex = "(.)\\1+"; //+代表第一组出现一次到多次
String[] arr = s.split(regex);
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}替换：
需求：我我....我...我.要...要要...要学....学学..学.编..编编.编.程.程.程..程
将字符串还原成:“我要学编程”。
public static void main(String[] args) {
//替换：需求：我我....我...我.要...要要...要学....学学..学.编..编编.编.程.程.程..程 将字符串还原成:“我要学编程”。
String s = "我我....我...我.要...要要...要学....学学..学.编..编编.编.程.程.程..程";
String s2 = s.replaceAll("\\.+", "");
String s3 = s2.replaceAll("(.)\\1+", "$1"); //$1获取到第一组的数据，即第一个()中的。
System.out.println(s3);
}12、Pattern和Matcher的概述：Pattern类：public final class Pattern extends Objects implements Serializable 正则表达式的编译表现形式。
13、模式和匹配器的典型调用顺序：
Pattern p = Pattern.compile("a*b");
Matcher m = p.matcher("aaaaab");
boolean b = m.matches();等价于：
System.out.println("aaaaab".matches("a*b")); 解析 典型调用顺序：
public static Pattern compile(String regex)。将给定的正则表达式编译到模式中。
public Matcher(CharSequence input)。创建匹配给定输入与此模式的匹配器。
public boolean matches()。尝试将整个区域与模式匹配。
14、正则表达式的获取功能：Pattern和Matcher的结合使用。
public boolean find()。尝试查找与该模式匹配的输入序列的下一个子序列。翻译：拿着正则到指定字符串找符合规则的子字符串。
public String group()。返回由以前匹配操作所匹配的输入子序列。翻译：获取找到的东西。
15、 案例演示：需求：把一个字符串中的手机号码获取出来。
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Test4 {
public static void main(String[] args) {
String s = "我的手机号码是18988888888，曾经用过18987654321，还用过18812345678";
String regex = "1[3578]\\d{9}"; //手机号码的正则表达式。
/*Pattern p = Pattern.compile(regex);
Matcher m = p.matcher(s);
boolean b = m.matches();
System.out.println(b);*/
Pattern p = Pattern.compile(regex);
Matcher m = p.matcher(s);
/*boolean b1 = m.find(); //再次调用会自动找到下一个。
System.out.println(b1);
String s1 = m.group(); //一定要先找再获取。
System.out.println(s1);*/
while(m.find())
System.out.println(m.group());
}
}
Math类
1、Math类概述： public final class Math extends Object，Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。java.lang包下。Math类所有成员静态，会私有构造方法，目的是不让其他类创建本类对象。
2、Math类的成员属性：public static double PI。比任何其他值都更接近pi（即圆的周长与半径之比）的double值。
3、Math类的成员方法：
| public static int abs(int a) | 取绝对值。 |
| public static double ceil(double a) | ceil天花板。向上取整，但结果是一个double值。 |
| public static double floor(double a) | floor地板。向下取整，结果也是一个double值。 |
| public static int max(int a, int b) | 获取两个值中的最大值。 |
| public static int min(int a, int b) | 获取两个值中的最小值。 |
| public static double pow(double a, double b) | 前面的数是底数，后面的数是指数。a^b。 |
| public static double random() | 生成0.0到1.0之间的所有小数，包括0.0，不包括1.0。 |
| public static int round(float a) | 四舍五入。 |
| public static int round(doublc a) | 四舍五入。 |
| public static double sqrt(double a) | 开平方。 |
Random类
1、Random类的概述：public class Random extends Object，此类的实例用于产生伪随机数。如果用相同的种子创建两个 Random 实例，则对每个实例进行相同的方法调用序列，它们将生成并返回相同的数字序列。java.util包下，使用需要导包。
2、Random类的构造方法：
ⅰ.public Random() 创建一个新的随机数生成器。种子是纳秒值，是不断变化的。
ⅱ.public Random(long seed) 使用单个long种子创建一个新的随机数生成器。
使用种子后，nextInt()的结果无论运行几次都是一样的。
3、Random类的成员方法：
ⅰ.public int nextInt() 返回下一个伪随机数，它是此随机数生成器的序列中均匀分布的int值。
翻译：生成一个int取值范围内的随机数。
ⅱ.public int nextInt(int n) 返回一个伪随机数，它是取自此随机数生成器序列的、在0（包括）和指定值（不包括）之间均匀分布的int值。
nextInt的常规协定是：伪随机地生成并返回指定范围中的一个int值。所有可能的n个int值的生成概率（大致）相同。
System类
1、System类的概述：
public final class System extends Object，System 类包含一些有用的类字段和方法。它不能被实例化，成员均被static修饰，私有了空参构造方法，无有参构造方法。 java.lang包下。final修饰，不能有子类。
在System提供的设施中，有标准输入、标准输出、和错误输出流；对外部定义的属性和环境变量的访问；加载文件和库的方法；还有快速复制数组的一部分的实用方法。
2、System类的成员属性（流中详细介绍）：
public static PrintStream err “标准”错误输出流。
public static InputStream in “标准”输入流。键盘输出流。
public static PrintStream out “标准”输出流。默认指向控制台。
3、System类的成员方法：
public static void gc() 运行垃圾回收器，相当于呼喊保洁阿姨。
调用gc方法暗示着Java虚拟机做了一些努力来回收未用对象，以便能够快速地重用这些对象当前占用的内存。当控制权从方法调用中返回时，虚拟机已经尽最大努力从所有丢弃的对象中回收了空间。
调用SystemSystem.gc实际上等效于调用：Runtime.getRuntime().ge()。
Object -- protected void finalize() 当垃圾回收器确定不存在该对象的更多引用时，由对象的垃圾回收器调用此方法。
public static void exit(int status) 终止当前正在运行的Java虚拟机。
参数用作状态码，根据惯例，非0的状态码表示异常终止。该方法调用Runtime类中的exit方法。该方法永远不会正常返回。
调用System.exit(n)实际上等效于调用：Runtime.getRuntime().exit(n)。
public static long currentTimeMillis() 返回以毫秒为单位的当前时间。
注意，当返回时间单位是毫秒时，值的粒度取决于底层操作系统，并且粒度可能更大。例如，许多操作系统以几十毫秒为单位测量时间。
返回：当前时间与协调世界时1970年1月1日午夜之间的时间差（以毫秒为单位测量）。1秒 = 1000毫秒。
pubiic static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。
参数：
src 源数组。 srcPos 源数组中的起始位置。 dest 目标数组。 destPos 目标数组中的起始位置。 length 要复制的数组元素的数量。 演示：System.arraycopy(src, 0, dest, 0, src.length);
BigInteger类
1、BigInteger类的概述：public class BigInteger extends Number，可以让超过Integer范围内的数据进行运算。java.math包下，需要导包。不可改变的任意精度的整数。
2、BigInteger类的构造方法：
public BigInteger(String val) 将BigInteger的十进制字符串表示形式转换为BigInteger。
3、BigInteger类的成员方法：
| public BigInteger add(BigInteger val) | 返回其值为（this+val）的BigInteger。 |
| public BigInteger subtract(BigInteger val) | 返回其值为（this-val）的BigInteger。 |
| public BigInteger multiply(BigInteger val) | 返回其值为（this*val）的BigInteger。 |
| public BigInteger divide(BigInteger val) | 返回其值为（this/val）的BigInteger。 |
| public BigInteger[] divideAndRemainder(BigInteger val) | 返回包含（this/val）后跟（this%val）的两个BigInteger的数组。 |
BigDecimal类
1、BigDecimal类的概述：public class BigDecimal extends Number，不可变的、任意精度的有符号十进制数。由于在运算的时候，float类型和double很容易丢失精度。所以，为了能精确的表示、计算浮点数，Java提供了BigDecimal。java.math包下，需要导包。
2、BigDecimal类的构造方法：
public BigDecimal(double val) 将double转换为BigDecimal，后者是double的二进制浮点值准确的十进制表示形式。很精确但不精准，小数点后的数位更多了，不推荐。
public BigDecimal(String val) 将BigDecimal的字符串表示形式转换为BigDecimal。自己new对象，很精准，推荐。
3、BigDecimal类的成员方法：（加减乘除与BigInteger一致）
| public BigDecimal add(BigDecimal augend) | 返回 BigDecimal，其值是 (this + augend) |
| public BigDecimal subtract(BigDecimal subtrahend) |
返回 BigDecimal，其值是 (this - subtrahend) |
| public BigDecimal multiply(BigDecimal multiplicand) |
返回 BigDecimal，其值是 (this × multiplicand) |
| public BigDecimal divide(BigDecimal divisor) |
返回BigDecimal，其值为(this / divisor) |
| public static BigDecimal valueOf(double val) |
使用Double.toString(double)方法提供的double规范的字符串表示形式将double转换为BigDecimal。调方法，在底层new对象，也很精准，推荐。 |
Date类（日期类）
1、Date类的概述：public class Date extends Object，类 Date 表示特定的瞬间，精确到毫秒。 绝大部分方法过时了，我们只学不过时的。java.util包下，需要导包。注意不要导成sql包。
2、Date类的构造方法：
构造方法没有传参代表当前时间，参数为0代表1970年1月1日。
public Date() 分配Date对象并初始化此对象，以表示分配它的时间（精确到毫秒）。CST中央时区。
public Date(long date) 分配Date对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”），即1970年1月1日 00:00:00 GMT）以来的指定毫秒数。通过毫秒值创建时间对象。
面试题：
System.out.println(new Date(0))，打印出来的时间是8点而非零点，原因是存在操作系统本地时间的问题，其实系统时间依然是0点，只不过我的电脑时区设置为东8区，故打印的结果是8点。
3、Date类的成员方法：
public long getTime() 返回自1970年1月1日 00:00:00 GMT以来此Date对象表示的毫秒数。作用与System.currentTimeMillis()相同。
前者通过时间对象获取毫秒值。后者通过系统类的方法获取当前时间毫秒值。
public void setTime(long time) 设置毫秒值，改变时间对象。其值为历元加上设置的毫秒值。
DateFormat类
1、DateFormat类的概述：public abstract class DateFormatextends Format，DateFormat 是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并解析日期或时间。是抽象类，不能被实例化，所以使用其子类SimpleDateFormat。java.text包下，使用需要导包。
2、案例：
DateFormat df1 = DateFormat.getInstance(); //相当于父类引用指向子类对象，右边的方法返回一个子类对象。相当于：
DateFormat df1 = new SimpleDateFormat();前者底层封装好了，后者需要自己实现。
3、DateFormat类构造：
protected DateFormat()创建一个新的DateFormat。不能用来new对象，为子类提供初始化使用。
SimpleDateFormat类
1、SimpleDateFormat类的概述：public class SimpleDateFormat extends DateFormat，SimpleDateFormat 是一个以与语言环境有关的方式来格式化和解析日期的具体类。拥有DateFormat类所有的功能。java.text包下，使用需要导包。
2、SimpleDateFormat类的构造方法：
public SimpleDateFormat() 用默认的模式和默认语言环境的日期格式符号构造SimpleDateFormat。
public SimpleDateFormat(String pattern) 用给定的模式和默认语言环境的日期格式符号构造SimpleDateFormat。
演示：
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");3、SimpleDateFormat类的成员方法：
public StringBuffer format(Date date, StringBuffer toAppendTo, FieldPosition pos)将给定的Date格式化为日期/时间字符串，并将结果添加到给定的StringBuffer 。
父类的另一个format：public abstract StringBuffer format(Date date, StringBuffer toAppendTo, FieldPosition fieldPosetion)将一个Date格式化为日期/时间字符串。
参数：date - 要格式化为日期/时间字符串的Date。
toAppendTo - 用于返回的日期/时间字符串的字符串缓冲区。
fieldPosition - 跟踪返回字符串中字段的位置。输入时：如果需要，是一个对齐字段。输出时：对齐字段的偏移量。
public Date parse(String text, ParsePosition pos)解析时间字符串的文本，生成Date对象。
父类的另一个parse：public abstract Date parse(String source, ParsePosition pos)根据给定的解析位置开始解析日期/时间字符。有参构造的格式需与时间字符串中的相同。
但我们主要用他父类中的方法：
public final String format(Date date) 参数是一个Date对象。固定格式。
父类的format：public final String format(Date date)将一个Date格式化为日期/时间字符串。 参数：date-要格式化为时间字符串的时间值。返回：已格式化的时间字符串。
public Date parse(String source)
父类的parse：public Date parse(String source) throws ParseException。从给定字符串的开始解析文本，以生成一个日期。该方法不使用给定字符串的整个文本。 返回值是个Date对象，用Date类型变量接收。
4、日期和时间格式由日期和时间模式字符串指定。
| Letter | Date or Time Component | Presentation | Examples |
|---|---|---|---|
G |
Era designator | Text | AD |
y |
Year | Year | 1996; 96 |
Y |
Week year | Year | 2009; 09 |
M |
Month in year (context sensitive) | Month | July; Jul; 07 |
L |
Month in year (standalone form) | Month | July; Jul; 07 |
w |
Week in year | Number | 27 |
W |
Week in month | Number | 2 |
D |
Day in year | Number | 189 |
d |
Day in month | Number | 10 |
F |
Day of week in month | Number | 2 |
E |
Day name in week | Text | Tuesday; Tue |
u |
Day number of week (1 = Monday, ..., 7 = Sunday) | Number | 1 |
a |
Am/pm marker | Text | PM |
H |
Hour in day (0-23) | Number | 0 |
k |
Hour in day (1-24) | Number | 24 |
K |
Hour in am/pm (0-11) | Number | 0 |
h |
Hour in am/pm (1-12) | Number | 12 |
m |
Minute in hour | Number | 30 |
s |
Second in minute | Number | 55 |
S |
Millisecond | Number | 978 |
z |
Time zone | General time zone | Pacific Standard Time; PST; GMT-08:00 |
Z |
Time zone | RFC 822 time zone | -0800 |
X |
Time zone | ISO 8601 time zone | -08; -0800; -08:00 |
5、举例如何在美国地区中解释日期和时间模式。
| Date and Time Pattern | Result |
|---|---|
"yyyy.MM.dd G 'at' HH:mm:ss z" |
2001.07.04 AD at 12:08:56 PDT |
"EEE, MMM d, ''yy" |
Wed, Jul 4, '01 |
"h:mm a" |
12:08 PM |
"hh 'o''clock' a, zzzz" |
12 o'clock PM, Pacific Daylight Time |
"K:mm a, z" |
0:08 PM, PDT |
"yyyyy.MMMMM.dd GGG hh:mm aaa" |
02001.July.04 AD 12:08 PM |
"EEE, d MMM yyyy HH:mm:ss Z" |
Wed, 4 Jul 2001 12:08:56 -0700 |
"yyMMddHHmmssZ" |
010704120856-0700 |
"yyyy-MM-dd'T'HH:mm:ss.SSSZ" |
2001-07-04T12:08:56.235-0700 |
"yyyy-MM-dd'T'HH:mm:ss.SSSXXX" |
2001-07-04T12:08:56.235-07:00 |
"YYYY-'W'ww-u" |
2001-W27-3 |
6、案例：需求：算一下你来到这个世界多少天?
package com.test;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
* 需求：算一下你来到这个世界多少天?
* 分析：1.将生日字符串和今天字符串存储在String类型的变量中。
* 2.定义日期格式化对象。
* 3.将日期字符串转换成日期对象。
* 4.通过日期对象获取时间毫秒值。
* 5.将两个时间毫秒值相减除以1000变成秒，再除以60变成分钟，再除以60变成小时，再除以24得到天。
*/
public class Test5 {
public static void main(String[] args) throws ParseException {
//1.将生日字符串和今天字符串存储在String类型的变量中。
String birthday = "1999年9月18日";
String today = "2018年11月9日";
//2.定义日期格式化对象。
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");
//3.将日期字符串转换成日期对象。
Date d1 = sdf.parse(birthday);
Date d2 = sdf.parse(today);
//4.通过日期对象获取时间毫秒值。
long time = d2.getTime() - d1.getTime();
//5.将两个时间毫秒值相减除以1000变成秒，再除以60变成分钟，再除以60变成小时，再除以24得到天。
System.out.println(time / 1000 / 60 / 60 / 24);
}
}Calendar类
1、Calendar类（日历类）的概述：
public abstract classCalendar extends Object，Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。
瞬间可用毫秒值来表示，它是距历元（即格林威治标准时间1970年1月1日的 00:00:00.000，格里高利历）的偏移量。Calendar类替代了很多Date类的方法。java.util包下，使用需要导包。
2、Calendar类的成员方法：
public static Calendar getInstance()
使用：
Calendar rightNow = Calendar.getInstance(); //父类引用指向子类对象。getInstance()方法返回一个子类对象。
public int get(int field) 参数为int字段。
3、参数调用字段格式：
YEAR字段：public static final int YEAR。指示年的get和set的字段数字。常量，类名.调用即可。Calendar.YEAR。
MONTH字段：public static final int MONTH。指示月份的get和set的字段数字。这是一个特定于日历的值。在格里高利历和罗马儒略历中一年中的第一个月是JANUARY，它为0；最后一个月取决于一年中的月份数。
DAY_OF_MONTH字段：public static final int DAY_OF_MONTH。get和set的字段数字，指示一个月中的某天。
DAY_OF_WEEK字段：public static final int DAY_OF_WEEK。get和set的字段数字，指示一个星期中的某天。周日是第一天，周六是最后一天。
4、演示：输出现在的时间：
public static void main(String[] args) {
Calendar c = Calendar.getInstance();
System.out.println(c.get(Calendar.YEAR) + "年" + getNum((c.get(Calendar.MONTH) + 1))
+ "月" + getNum(c.get(Calendar.DAY_OF_MONTH)) + "日" + getWeek(c.get(Calendar.DAY_OF_WEEK)));
}
/**
* 将星期存储表中进行查表
* 1.返回值类型String
* 2.参数列表int week
*/
public static String getWeek(int week) { //查表法
String[] arr = {"","星期日","星期一","星期二","星期三","星期四","星期五","星期六"};
return arr[week];
}
/**
* 如果是个位数字，前面补0
* 1.返回值类型String
* 2.参数列表int num
*/
public static String getNum(int num) {
return num > 9 ? "" + num : "0" + num;
}
}5、Calendar类的成员方法：
| public void add(int field, int amount) | 对指定的字段执行向前减或向后加（传负数）。 |
| public void set(iint fied, int value) | 修改指定字段为传入值。 |
| public final void set(int year, int month, int date) | 设置年月日。 |
6、案例演示：需求：键盘录入任意一个年份，判断该年是闰年还是平年。
package com.test;
import java.util.Calendar;
import java.util.Scanner;
/**
* 需求：键盘录入任意一个年份，判断该年是闰年还是平年。
* 分析：
* 1.键盘录入年Scanner。
* 2.创建Calendar对象。Calendar c = Calendar.getInstance();
* 3.通过set方法设置为那一年的3月1日。
* 4.将日向前减去一，变成二月最后一天。
* 5.判断此日是第多少天，如果是29天返回true，否则返回false。
*/
public class Test6 {
public static void main(String[] args) {
//1.键盘录入年Scanner。
Scanner sc = new Scanner(System.in);
System.out.println("请输入年份，判断该年是闰年还是平年：");
// int year = sc.nextInt();
String line = sc.nextLine(); //录入数字字符串
int year = Integer.parseInt(line);//将数字字符串转换成数字
boolean b = getYear(year);
System.out.println(b);
}
private static boolean getYear(int year) {
//2.创建Calendar对象。Calendar c = Calendar.getInstance();
Calendar c = Calendar.getInstance();
//3.通过set方法设置为那一年的3月1日。
c.set(year, 2, 1);
//4.将日向前减去一，变成二月最后一天。
c.add(Calendar.DAY_OF_MONTH, -1);
//5.判断此日是第多少天，如果是29天返回true，否则返回false。
return c.get(Calendar.DAY_OF_MONTH) == 29;
}
}