B:日期和字符串的转换（SimpleDateFormat类） 111
B:根据日历字段和一个正负数确定是添加还是减去对应日历字段的值 115
第十四天
1. 正则表达式(理解)
(1)定义：
就是符合一定规则的字符串
(2)常见规则
A:字符
x 字符 x。举例：'a'表示字符a
\\ 反斜线字符。
\n 新行（换行）符 ('\u000A')
\r 回车符 ('\u000D')
B:字符类
[abc] a、b 或 c（简单类）（只能同时匹配单个字符）
[^abc] 任何字符，除了 a、b 或 c（否定）
[a-zA-Z] a到 z 或 A到 Z，两头的字母包括在内（范围）
[0-9] 0到9的字符都包括
C:预定义字符类
. 任何字符。我的就是.字符本身，怎么表示呢? \.
\d 数字：[0-9]
\w 单词字符：[a-zA-Z_0-9]
在正则表达式里面组成单词的东西必须由这些东西组成
D:边界匹配器
^ 行的开头
$ 行的结尾
\b 单词边界
就是不是单词字符的地方。
举例：hello world?haha;xixi
E:Greedy 数量词
X? X，一次或一次也没有 ，也就是0次或者1次
X* X，零次或多次
X+ X，一次或多次
X{n} X，恰好 n 次
X{n,} X，至少 n 次
X{n,m} X，至少 n 次，但是不超过 m 次
(3)常见功能：(分别用的是谁呢?)
A:判断功能
String类的public
boolean matches(String regex)
B:分割功能
String类的public String[] split(String regex)
C:替换功能
String类的public String replaceAll(String regex,String replacement)
说明：使用给定的replacement替换此字符串所有匹配给定的正则表达式的子字符串
D:获取功能
Pattern和Matcher
//把规则编译成模式对象
Pattern p = Pattern.compile("a*b");
//利用模式对象来生成匹配器对象
Matcher m = p.matcher("aaaaab");
find():查找是否存在下一个匹配的元素
group():获取刚才匹配成功的数据
注意事项：调用group() 方法之前，必须先调用find() 方法
(4)案例
A:判断电话号码和邮箱
|
import java.util.Scanner; /* * 需求：校验邮箱 * * 分析： * A:键盘录入邮箱 * B:定义邮箱的规则 * 1517806580@qq.com * liuyi@163.com * linqingxia@126.com * fengqingyang@sina.com.cn * fqy@itcast.cn * C:调用功能，判断即可 * D:输出结果 */ public class RegexTest { public static void main(String[] args) { //键盘录入邮箱 Scanner sc = new Scanner(System.in); System.out.println("请输入邮箱："); String email = sc.nextLine();
//定义邮箱的规则 //String regex = "[a-zA-Z_0-9]+@[a-zA-Z_0-9]{2,6}(\\.[a-zA-Z_0-9]{2,3})+"; String regex = "\\w+@\\w{2,6}(\\.\\w{2,3})+";
//调用功能，判断即可 boolean flag = email.matches(regex);
//输出结果 System.out.println("flag:"+flag); } } |
B:按照不同的规则分割数据
|
import java.util.Arrays; /* * 需求：我有如下一个字符串:"91 27 46 38 50" * 请写代码实现最终输出结果是："27 38 46 50 91" * * 分析： * A:定义一个字符串 * B:把字符串进行分割，得到一个字符串数组 * C:把字符串数组变换成int数组 * D:对int数组排序 * E:把排序后的int数组在组装成一个字符串 * F:输出字符串 */ public class RegexTest { public static void main(String[] args) { // 定义一个字符串 String s = "91 27 46 38 50";
// 把字符串进行分割，得到一个字符串数组 String[] strArray = s.split(" ");
// 把字符串数组变换成int数组 int[] arr = new int[strArray.length];
for (int x = 0; x < arr.length; x++) { arr[x] = Integer.parseInt(strArray[x]); }
// 对int数组排序 Arrays.sort(arr);
// 把排序后的int数组在组装成一个字符串 StringBuilder sb = new StringBuilder(); for (int x = 0; x < arr.length; x++) { sb.append(arr[x]).append(" "); } //转化为字符串 String result = sb.toString().trim();
//输出字符串 System.out.println("result:"+result); } } |
C:把论坛中的数字替换为*
|
/* * 替换功能 String类的public String replaceAll(String regex,String replacement) 使用给定的 * replacement 替换此字符串所有匹配给定的正则表达式的子字符串。 */ class RegexDemo { public static void main(String[] args) { // 定义一个字符串 String s = "helloqq12345worldkh622112345678java";
// 我要去除所有的数字,用*给替换掉 // String regex = "\\d+"; // String regex = "\\d"; // String ss = "*";
// 直接把数字干掉 String regex = "\\d+"; String ss = "";
String result = s.replaceAll(regex, ss); System.out.println(result); } } |
D:获取字符串中由3个字符组成的单词
|
import java.util.regex.Matcher; import java.util.regex.Pattern;
/* * 获取功能： * 获取下面这个字符串中由三个字符组成的单词 * da jia ting wo shuo,jin tian yao xia yu,bu shang wan zi xi,gao xing bu? */ class RegexDemo2 { public static void main(String[] args) { // 定义字符串 String s = "da jia ting wo shuo,jin tian yao xia yu,bu shang wan zi xi,gao xing bu?"; // 规则 String regex = "\\b\\w{3}\\b";
// 把规则编译成模式对象 Pattern p = Pattern.compile(regex); // 通过模式对象得到匹配器对象 Matcher m = p.matcher(s); // 调用匹配器对象的功能 // 通过find方法就是查找有没有满足条件的子串 // public boolean find() // boolean flag = m.find(); // System.out.println(flag); // // 如何得到值呢? // // public String group() // String ss = m.group(); // System.out.println(ss); // // // 再来一次 // flag = m.find(); // System.out.println(flag); // ss = m.group(); // System.out.println(ss);
//如果匹配到值，就返回 while (m.find()) { System.out.println(m.group()); }
// 注意：一定要先find()，然后才能group() // IllegalStateException: No match found // String ss = m.group(); // System.out.println(ss); } } |
2. Math(掌握)
(1)定义：
用于数学运算的类
(2)常见方法
A:绝对值：public
static
int abs(int
a)
B:向上取整：public
static
double ceil(double
a)
C:向下取整：public
static
double floor(double
a)
D:两个数据中的大值：public
static
int max(int
a, int
b)
E:a的b次幂：public
static
double pow(double
a, double
b)
F:随机数：public
static
double random()
G:四舍五入：public
static
int round(float
a)
H:正平方根：public
static
double sqrt(double
a)
(3）成员变量
public
static
final
double
E = 2.7182818284590452354;
public
static
final
double
PI = 3.14159265358979323846;
(4)案例：
A:猜数字小游戏
|
import java.util.Random; import java.util.Scanner;
/* * 动态产生一个 1 - 100 之间的数字，记录猜中结果的次数 */ public class GuessGame {
public static void startGame() { Random ran = new Random();
//获取到的随机数 int num = ran.nextInt(100) + 1; //定义一个统计变量 int count = 0;
while(true) { Scanner sc = new Scanner(System.in); System.out.println("你输入你猜中的数字："); int n = sc.nextInt(); count++; //比较数字 if (num == n) { System.out.println("恭喜你，" + count + "次就猜中啦，好厉害呀！"); break; } else if (num > n) { System.out.println("你猜的数字小了！继续加油吧..."); } else if (num < n) {
System.out.println("你猜的数字大了！还差一点喔..come on baby."); }
} }
} |
B:获取任意范围的随机数
|
import java.util.Scanner;
/* * 需求：请设计一个方法，可以实现获取任意范围内的随机数。 * * 分析： * A:键盘录入两个数据。 * int strat; * int end; * B:想办法获取在start到end之间的随机数 * 我写一个功能实现这个效果，得到一个随机数。(int) * C:输出这个随机数 */ public class MathDemo { public static void main(String[] args) { // Scanner sc = new Scanner(System.in); System.out.println("请输入开始数："); int start = sc.nextInt(); System.out.println("请输入结束数："); int end = sc.nextInt();
for (int x = 0; x < 100; x++) { // 调用功能 int num = getRandom(start, end); // 输出结果 System.out.println(num); } }
/* * 写一个功能 两个明确： 返回值类型：int * 1、 1 - 100 之间随机数的获取： (int)(Math.random() * 100) + 1; 2、同理： 200 - * 300之间随机数为：(int)(Math.random() * 300) + 200; 这真的正确吗？ 现在的范围就变为了:[0,300) 、如果更改为： (int)(Math.random() * (300 - * 200 + 1)) + 200； 呢？ 现在的范围为：[0,100] 然后 加上 200 ------》 变为了 * [200,300],这是我们想要的 */ public static int getRandom(int start, int end) { // 回想我们讲过的1-100之间的随机数 // int number = (int) (Math.random() * 100) + 1; // int number = (int) (Math.random() * end) + start; // 发现有问题了，怎么办呢? int number = (int) (Math.random() * (end - start + 1)) + start; return number; } } |
3. Random(理解)
(1)定义：
用于产生随机数的类
(2)构造方法:
A: public Random()：
没有给出种子，用的是默认种子（当前时间的毫秒值），每次产生的随机数不同
B: public Random(long
seed)
：
指定种子，给定种子后，每次得到的随机数是相同的
(3)成员方法:
A: public
int nextInt()
：返回int类型范围内的随机数
B: public
int nextInt(int
n) ： 返回[0,n)范围内的随机数
(4)代码演示
|
import java.util.Random; /* * Random:产生随机数的类 * * 构造方法： * public Random():没有给种子，用的是默认种子，是当前时间的毫秒值 * public Random(long seed):给出指定的种子 * 给定种子后，每次得到的随机数是相同的。 * * 成员方法： * public int nextInt()：返回的是int类型范围内的随机数 * public int nextInt(int n):返回的是[0,n)范围内随机数 */ class RandomDemo { public static void main(String[] args) { // 创建对象 // Random r = new Random(); Random r = new Random(1111);
for (int x = 0; x < 10; x++) { // int num = r.nextInt(); int num = r.nextInt(100) + 1; System.out.println(num); } } } |
4. System(掌握)
(1)定义：
系统类,提供了一些有用的字段和方法
(2)成员方法
A:运行垃圾回收器：
public
static
void gc()
执行System.gc()前，系统会自动调用finalize()方法清除对象占有的资源
B:退出jvm：
public
static
void exit(int
status)
终止当前正在运行的 Java 虚拟机。参数用作状态码；
根据惯例，非 0 的状态码表示异常终止。
演示：
|
/* * System类包含一些有用的类字段和方法。它不能被实例化。 * 方法： * public static void exit(int status):终止当前正在运行的 Java 虚拟机。 * 参数用作状态码；根据惯例，非 0 的状态码表示异常终止。 */ class SystemDemo { public static void main(String[] args) { System.out.println("我们喜欢林青霞(东方不败)"); System.exit(0); System.out.println("我们也喜欢赵雅芝(白娘子)"); } } |
C:获取当前时间的毫秒值：
public
static
long currentTimeMillis()
演示：
|
/* * System类包含一些有用的类字段和方法。它不能被实例化。 * * 方法： * public static long currentTimeMillis():返回以毫秒为单位的当前时间 */ class SystemDemo { public static void main(String[] args) { // System.out.println(System.currentTimeMillis());
// 单独得到这样的实际目前对我们来说意义不大 // 那么，它到底有什么作用呢? // 要求：请大家给我统计这段程序的运行时间 long start = System.currentTimeMillis(); for (int x = 0; x < 100000; x++) { System.out.println("hello" + x); } long end = System.currentTimeMillis(); System.out.println("共耗时：" + (end - start) + "毫秒"); } } |
D:数组复制：
public
static
void arraycopy(Object src, int
srcPos,
Object dest, int
destPos, int
length)
从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。
并复制几个元素
演示：
|
import java.util.Arrays;
/* * System类包含一些有用的类字段和方法。它不能被实例化。 * 方法： * public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length) * 从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。 */ class SystemDemo { public static void main(String[] args) { // 定义数组 int[] arr = { 11, 22, 33, 44, 55 }; int[] arr2 = { 6, 7, 8, 9, 10 };
// 请大家看这个代码的意思 System.arraycopy(arr, 1, arr2, 2, 2); //结果：[ 11, 22, 33, 44, 55 ] System.out.println(Arrays.toString(arr)); //结果：[6, 7, 22, 33, 10] System.out.println(Arrays.toString(arr2)); } } |
5. BigInteger(理解)
(1)说明：
针对大整数的运算
(2)构造方法
A: public BigInteger(String s)
(3)成员方法
A:加
public BigInteger add(BigInteger val)
B:减
public BigInteger subtract(BigInteger val)
C:乘
public BigInteger multiply(BigInteger val)
D:除
public BigInteger divide(BigInteger val)
E:返回商和余数的数组：也就是Biginter[0] = 商 Biginter[1] = 余数
public BigInteger[] divideAndRemainder(BigInteger val)
(4)代码演示：
|
import java.math.BigInteger;
class BigIntegerDemo { public static void main(String[] args) { BigInteger bi1 = new BigInteger("100"); BigInteger bi2 = new BigInteger("50");
// public BigInteger add(BigInteger val):加 System.out.println("add:" + bi1.add(bi2)); // public BigInteger subtract(BigInteger val):加 System.out.println("subtract:" + bi1.subtract(bi2)); // public BigInteger multiply(BigInteger val):加 System.out.println("multiply:" + bi1.multiply(bi2)); // public BigInteger divide(BigInteger val):加 System.out.println("divide:" + bi1.divide(bi2));
// public BigInteger[] divideAndRemainder(BigInteger val):返回商和余数的数组 BigInteger[] bis = bi1.divideAndRemainder(bi2); System.out.println("商：" + bis[0]); System.out.println("余数：" + bis[1]); } } |
6. BigDecimal(理解)
(1)定义：
（float、double）浮点数据做运算，会丢失精度。所以，
针对浮点数据的操作建议采用BigDecimal。(金融相关的项目)
(2)构造方法
A: public BigDecimal(String s)
(3)成员方法：
A:加
public BigDecimal add(BigDecimal augend)
B:减
public BigDecimal subtract(BigDecimal subtrahend)
C:乘
public BigDecimal multiply(BigDecimal multiplicand)
D:除
public BigDecimal divide(BigDecimal divisor)
E:自己保留小数几位
public BigDecimal divide(BigDecimal divisor, int
scale, RoundingMode roundingMode)
参数列表说明：divisor：商
Scale：保留几位小数
roundingMode：取舍模式（一般为BigDecimal.ROUND_HALF_UP）
(4)代码演示
|
import java.math.BigDecimal;
class BigDecimalDemo { public static void main(String[] args) { /* * * 看程序写结果：结果和我们想的有一点点不一样，这是因为float类型的数据存储和整数不一样导致的。它们大部分的时候，都是带有有效数字位。 * * 由于在运算的时候，float类型和double很容易丢失精度，演示案例。所以，为了能精确的表示、计算浮点数，Java提供了BigDecimal * * BigDecimal类：不可变的、任意精度的有符号十进制数,可以解决数据丢失问题。 */ // System.out.println(0.09 + 0.01); //0.09999999999999999 // System.out.println(1.0 - 0.32);//0.6799999999999999 // System.out.println(1.015 * 100);//101.49999999999999 // System.out.println(1.301 / 100);// 0.013009999999999999
//为了解决上面丢失精度的问题，需要使用 BigDecimal bd1 = new BigDecimal("0.09"); BigDecimal bd2 = new BigDecimal("0.01"); //相加运算 System.out.println("add:" + bd1.add(bd2)); System.out.println("-------------------");
BigDecimal bd3 = new BigDecimal("1.0"); BigDecimal bd4 = new BigDecimal("0.32"); //想减运算 System.out.println("subtract:" + bd3.subtract(bd4)); System.out.println("-------------------");
BigDecimal bd5 = new BigDecimal("1.015"); BigDecimal bd6 = new BigDecimal("100"); //相乘运算 System.out.println("multiply:" + bd5.multiply(bd6)); System.out.println("-------------------");
BigDecimal bd7 = new BigDecimal("1.301"); BigDecimal bd8 = new BigDecimal("100"); //相除运算 System.out.println("divide:" + bd7.divide(bd8)); //自己指定保留几位小数，和取舍模式 System.out.println("divide:" + bd7.divide(bd8, 3, BigDecimal.ROUND_HALF_UP)); System.out.println("divide:" + bd7.divide(bd8, 8, BigDecimal.ROUND_HALF_UP)); } } |
7. Date/DateFormat(掌握)
(1)Date 类的定义：
Date是日期类，可以精确到毫秒。
A:构造方法
public Date() ：根据当前的默认(系统)毫秒值创建日期对象
public Date(long
date) ：根据给定的毫秒值创建日期对象
代码演示：
|
import java.util.Date;
/* * Date:表示特定的瞬间，精确到毫秒。 * * 构造方法： * Date():根据当前的默认毫秒值创建日期对象 * Date(long date)：根据给定的毫秒值创建日期对象 */ class DateDemo { public static void main(String[] args) { // 用无参构造方法创建对象 Date d = new Date(); System.out.println("d:" + d);
// 用给定的毫秒值创建对象 // long time = System.currentTimeMillis(); long time = 1000 * 60 * 60; // 1小时 Date d2 = new Date(time); System.out.println("d2:" + d2); } } |
B:成员方法
public
long getTime() ：获取当前系统时间的毫秒值，以毫秒为单位
public
void setTime(long
time) ：用毫秒值设置时间
代码演示：
|
import java.util.Date;
/* * public long getTime():获取时间，以毫秒为单位 * public void setTime(long time):设置时间 * 注意事项：需要注意全球时区的不同，造成的时差 * * 从Date得到一个毫秒值 * getTime() * 把一个毫秒值转换为Date * 构造方法 * setTime(long time) */ class DateDemo { public static void main(String[] args) { // 创建对象 Date d = new Date();
// 获取时间 long time = d.getTime(); System.out.println(time); // System.out.println(System.currentTimeMillis());
System.out.println("d:" + d); // 设置时间，这里需要注意时区的问题 d.setTime(1000); System.out.println("d:" + d); } } |
C:日期和毫秒值的相互转换
|
import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date;
/* * Date -- String(格式化) * public final String format(Date date) * * String -- Date(解析) * public Date parse(String source) * * DateForamt:可以进行日期和字符串的格式化和解析，但是由于是抽象类，所以使用具体子类SimpleDateFormat。 * * SimpleDateFormat的构造方法： * SimpleDateFormat():默认模式 * SimpleDateFormat(String pattern):给定的模式 * 这个模式字符串该如何写呢? * 通过查看API，我们就找到了对应的模式 * 年 y * 月 M * 日 d * 时 H * 分 m * 秒 s * 月12日 12:12:12 */ public class DateTest3 {
public static void main(String[] args) {
// 创建日期对象 Date date = new Date(); // Date ----> String dateToString(date);
// String ----> Date String nowtime = "2016-12-09 15:36:25"; stringToDate(nowtime);
}
/** * 将具有指定格式的字符串解析为 Date对象 * * @param time */ public static void stringToDate(String time) { // 创建格式化对象 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
// 将字符串解析为Date Date date = null; try { date = sdf.parse(time); } catch (ParseException e) {
e.printStackTrace(); } System.out.println(date); }
/** * Date对象 格式化为 String对象（可以方便读取的时间字符串） * * @param date */ public static void dateToString(Date date) {
// 创建格式化对象 // SimpleDateFormat() SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
// 将日期对象进行格式化 // public final String format(Date date) String nowTime = sdf.format(date); // 输出格式化后的字符串 System.out.println(nowTime);
} } |
D:案例：你来到这个世界多少天了?
|
import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date; import java.util.Scanner;
/* * 案例：算一下你来到这个世界多少天? * * 分析： * A:键盘录入你的出生的年月日 * B:把该字符串转换为一个日期 * C:通过该日期得到一个毫秒值 * D:获取当前时间的毫秒值 * E:用D-C得到一个毫秒值 * F:把E的毫秒值转换为年 * /1000/60/60/24 */ class MyYearOldDemo { public static void main(String[] args) throws ParseException { // 键盘录入你的出生的年月日 Scanner sc = new Scanner(System.in); System.out.println("请输入你的出生年月日:"); String line = sc.nextLine();
// 把该字符串转换（解析）为一个日期 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); Date d = sdf.parse(line);
// 通过该日期得到一个毫秒值 long myTime = d.getTime();
// 获取当前时间的毫秒值 long nowTime = System.currentTimeMillis();
// 用D-C得到一个毫秒值 long time = nowTime - myTime;
// 把E的毫秒值转换为年 long day = time / 1000 / 60 / 60 / 24;
System.out.println("你来到这个世界：" + day + "天"); } } |
(2)DateFormat类的定义：
DateFormat针对日期进行格式化和针对字符串进行解析的类，但是是抽象类，
所以使用其子类SimpleDateFormat
A:构造方法
public SimpleDateFormat()：默认模式
public SimpleDateFormat(String pattern)：给定模式
常用模式：yyyy-MM-dd HH:mm:ss
B:日期和字符串的转换（SimpleDateFormat类）
a:Date
-
String
public
final String format(Date date)
b:String
--
Date
public Date parse(String source)
c:代码演示：
|
import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date;
/* * Date --> String(格式化) * public final String format(Date date) * * String --> Date(解析) * public Date parse(String source) * * DateForamt:可以进行日期和字符串的格式化和解析，但是由于是抽象类， * 所以使用具体子类SimpleDateFormat。 * * SimpleDateFormat的构造方法： * SimpleDateFormat():默认模式 * SimpleDateFormat(String pattern):给定的模式 * 这个模式字符串该如何写呢? * 通过查看API，我们就找到了对应的模式 * 年 y * 月 M * 日 d * 时 H * 分 m * 秒 s * 月12日 12:12:12 */ class DateFormatDemo { public static void main(String[] args) throws ParseException { // Date -- String // 创建日期对象 Date d = new Date(); // 创建格式化对象(无参)，没有给定模式 // SimpleDateFormat sdf = new SimpleDateFormat(); // 给定模式 SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss"); // public final String format(Date date) String s = sdf.format(d); System.out.println(s);
// String -- Date String str = "2008-08-08 12:12:12"; // 在把一个字符串解析为日期的时候，请注意格式必须和给定的字符串格式匹配 SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); Date dd = sdf2.parse(str); System.out.println(dd); } } |
C:案例：
制作了一个针对日期操作的工具类。
|
import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date;
/** * 这是日期和字符串相互转换的工具类 * * @author */ class DateUtil { private DateUtil() { }
/** * 这个方法的作用就是把日期转成一个字符串 * * @param d * 被转换的日期对象 * @param format * 传递过来的要被转换的格式 * @return */ public static String dateToString(Date d, String format) { // SimpleDateFormat sdf = new SimpleDateFormat(format); // return sdf.format(d); return new SimpleDateFormat(format).format(d); }
/** * 这个方法的作用就是把一个字符串解析成一个日期对象 * * @param s * 被解析的字符串 * @param format * 传递过来的要被转换的格式 * @return * @throws ParseException */ public static Date stringToDate(String s, String format) throws ParseException { return new SimpleDateFormat(format).parse(s); } } |
8. Calendar(掌握)
(1)定义：
日历类，封装了所有的日历字段值，通过统一的方法根据传入不同的日历字段可以获取值。
(2)如何得到一个日历对象呢?
Calendar rightNow = Calendar.getInstance();
本质返回的是子类对象
(3)成员方法
A:根据日历字段得到对应的值
public
int get(int
field)
常用的日历字段：
年：Calendar.YEAR
月：Calendar.MONTH
日：Calendar.DATE
代码演示：
|
import java.util.Calendar;
/* * Calendar:它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等 * 日历字段之间的转换提供了一些方法， * 并为操作日历字段（例如获得下星期的日期）提供了一些方法。 * * public int get(int field):返回给定日历字段的值。日历类中的每个日历字段都是静态的成员变量，并且是int类型。 */ class CalendarDemo { public static void main(String[] args) { // 其日历字段已由当前日期和时间初始化： Calendar rightNow = Calendar.getInstance(); // 子类对象
// 获取年 int year = rightNow.get(Calendar.YEAR); // 获取月 int month = rightNow.get(Calendar.MONTH); // 获取日 int date = rightNow.get(Calendar.DATE);
System.out.println(year + "年" + (month + 1) + "月" + date + "日"); } }
/*Calendar.getInstance(); 返回的对象是子类对象的解释 * abstract class Person { * public static Person getPerson() { * return new Student(); * } * } * class Student extends Person { * * } */ |
B:根据日历字段和一个正负数确定是添加还是减去对应日历字段的值
public
void add(int
field, int
amount)
C:设置日历对象的年月日
public
final
void set(int
year, int
month, int
date)
(4)方法演示：
|
import java.util.Calendar;
/* * public void add(int field,int amount):根据给定的日历字段和对应的时间， 来对当前的日历进行操作。 * public final void set(int year,int month,int date):设置当前日历的年月日 */ class CalendarDemo { public static void main(String[] args) { // 获取当前的日历时间 Calendar c = Calendar.getInstance();
// 获取年 int year = c.get(Calendar.YEAR); // 获取月 int month = c.get(Calendar.MONTH); // 获取日 int date = c.get(Calendar.DATE); System.out.println(year + "年" + (month + 1) + "月" + date + "日");
// // 三年前的今天 // c.add(Calendar.YEAR, -3); // // 获取年 // year = c.get(Calendar.YEAR); // // 获取月 // month = c.get(Calendar.MONTH); // // 获取日 // date = c.get(Calendar.DATE); // System.out.println(year + "年" + (month + 1) + "月" + date + "日");
天前 c.add(Calendar.YEAR, 5); c.add(Calendar.DATE, -10); // 获取年 year = c.get(Calendar.YEAR); // 获取月 month = c.get(Calendar.MONTH); // 获取日 date = c.get(Calendar.DATE); System.out.println(year + "年" + (month + 1) + "月" + date + "日"); System.out.println("--------------"); //设置当前日历的时间（包含年月日） c.set(2011, 11, 11); // 获取年 year = c.get(Calendar.YEAR); // 获取月 month = c.get(Calendar.MONTH); // 获取日 date = c.get(Calendar.DATE); System.out.println(year + "年" + (month + 1) + "月" + date + "日"); } } |
(5)案例：
计算任意一年的2月份有多少天?
|
import java.util.Calendar; import java.util.Scanner;
/* * 案例：获取任意一年的二月有多少天 * (所用的方法很巧妙) * * 分析： * A:键盘录入任意的年份 * B:设置日历对象的年月日 * 年就是A输入的数据 月的最后一天 * D:获取这一天输出即可 */ class CalendarTest { public static void main(String[] args) { // 键盘录入任意的年份 Scanner sc = new Scanner(System.in); System.out.println("请输入年份："); int year = sc.nextInt();
// 设置日历对象的年月日 Calendar c = Calendar.getInstance(); 月1日 月的最后一天 c.add(Calendar.DATE, -1);
// 获取这一天输出即可 System.out.println(c.get(Calendar.DATE)); } } |