Date、DateFormat、Calendar、Math、System、包装类、正则表达式

 

Date:

* 在java中如何表示一个时间对象呢?
* 需要使用到Date类,在java.util包下面;
* 使用步骤:
* 1. 导入包: import java.util.Date;
* 2. 创建对象,使用构造方法
* public Date();// 创建一个默认的当前时间点的日期对象.
* public Date(long time);// 根据指定的毫秒值创建日期对象
*
* 3. 使用成员方法:
* public void setTime(long time);// 为当前日期设置毫秒值
* public long getTime();// 获取日期对象的毫秒值
*
* 注意点:
* 1. Date类对象进行输出的时候,显示的不是地址值,说明已经覆盖了toString方法
* 2. 中国属于世界的东八区,默认的时间是: 1970年1月1日8:00
* 3. 世界的默认时间是格林尼治时间(英国南郊): 1970年1月1日0:00

public class Demo01Date {

public static void main(String[] args) {

//1.创建对象Date
Date date = new Date();
System.out.println(date);//Wed Dec 27 09:00:29 CST 2017

Date date2 = new Date(0L);
System.out.println(date2);//Thu Jan 01 08:00:00 CST 1970

System.out.println("=========");

//2.成员方法
//public long getTime();// 获取日期对象的毫秒值
System.out.println(date.getTime() / 1000 / 60 / 60 / 24 / 365);// 48年
System.out.println(date2.getTime());// 0
System.out.println("======");

// public void setTime(long time);// 设置毫秒值
// 练习: 获取明天的此时此刻
date.setTime(date.getTime() + 24 * 60 * 60 * 1000);
System.out.println(date);

}
}

 

 

 

DateFormat:
* 如何直接使用Date日期来表示时间,默认的时间,可读性不好,可是使用DateFormat来进行格式化.
* DateFormat: 表示时间格式化的类, 在java.text包下面;
* 由于DateFormat是一个抽象类,不能直接创建对象, 所以需要使用到子类: SimpleDateFormat;
*
* 使用步骤:
* 1. 导入包: import java.text.SimpleDateFormat; /DateFormat
* 2. 创建对象,使用构造方法:
* public SimpleDateFormat(String pattern);
* pattern: 可以传入指定的格式: "yyyy年MM月dd日 HH时mm分ss秒";
* 3. 使用成员方法
* public String format(Date date);// 将日期对象转成字符串
* public Date parse(String strTime);// 将字符串转成日期对象

package cn.itcast.demo02;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
//计算一个人活了多少天?
public class Demo03DatePractice {
public static void main(String[] args) throws ParseException {
String birthStr = "1995年09月16日";
DateFormat df = new SimpleDateFormat("yyyy年MM年dd月");
Date date1 = df.parse(birthStr);
Date date2 = new Date();
long day = (date2.getTime() - date1.getTime()) / 1000 / 60 / 60 / 24;
System.out.println("已经存活了" + day + "天");
}

}

 

或者

package cn.itcast.fudao02;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

// 请使用代码实现：计算你活了多少天
public class demo01 {
public static void main(String[] args) {
try {
// a)把你生日的字符串,转换为日期对象
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
Date birthDay = df.parse("1999-09-09");
// b)把日期对象转换为对应的毫秒值
System.out.println(birthDay);
long birthTime = birthDay.getTime();
// c)获取当前系统的毫秒值
long now = System.currentTimeMillis();//调用sysytem的方法,获取当前系统的毫秒值
// d)当前系统毫秒值-出生时间对于的毫秒值计算你活的毫秒值
long liveTime = now - birthTime;
// e)把你活毫秒值转换为天
long day = liveTime / 1000 / 60 / 60 / 24;
// f)输出天数
System.out.println("活了" + day + "天");
} catch (ParseException e) {
e.printStackTrace();
}
}
}

　　

 Calendar:
* 如果使用Date没有办法很好的表示,今天是今年的多少天,本周是今年的多少周...等等信息
* 如果需要表示的更加丰富,可以使用Calendar, 在java.util包下面;
* Calendar类: 表示日历对象的一个类,是一个抽象类没有办法创建对象,需要用到子类,在java.util.Calendar;
*
* 使用步骤:
* 1. 导入包: import java.util.Calendar;
* 2. 创建对象,使用构造方法
* 由于Calendar是抽象类,可以使用子类: GregorianCalendar
* 3. 使用成员方法;
* public static Calendar getInstance();// 静态方法,也可以获取一个日历对象(推荐使用)
* public Date getTime();// 获取日期对象
* public int get(int field);// field指的是字段信息(在Calendar中的字段(静态成员变量)里面)
* public void set(int field, int value);// 设置某一个字段为具体的值
* public void set(int year, int month, int day);// 设置具体的年月日
* public void add(int field, int amout);// 将某个字段对应的日期移动(增加或者减少)
*
* 注意:
* 获取月份表示范围是[0,11]表示[1,12]月份

public class Demo04Calendar {

public static void main(String[] args) {

//1. 创建对象
//Calendar c = new GregorianCalendar();
//System.out.println(c);

//2. public static Calendar getInstance();
// 静态方法,也可以获取一个日历对象(推荐使用)
Calendar c2 = Calendar.getInstance();
//System.out.println(c2);

//3. public Date getTime(); 获取一个日期对象
Date date = c2.getTime();
System.out.println(date); //Wed Dec 27 10:02:45 CST 2017
System.out.println(new Date());

System.out.println("======");

//4. public int get(int field);
// field指的是静态字段信息(在Calendar中的字段里面)
System.out.println(c2.get(Calendar.YEAR) + "年");
System.out.println(c2.get(Calendar.MONTH) + 1 + "月");// 月份获取的是[0,11]表示[1,12]月份
System.out.println(c2.get(Calendar.DAY_OF_MONTH) + "日");

//5. public void set(int field, int value);
// 设置某一个字段为具体的值
c2.set(Calendar.YEAR, 2018);// 将年份改成2018年
c2.set(Calendar.MONTH, 9);// 设置成10月份
System.out.println(c2.getTime());// 获取的是日历里面的日期对象
System.out.println("=======");

//6.public void set(int year, int month, int day);
// 设置具体的年月日
c2.set(2020, 9, 10);// 设置成2020年的10月10日
Date date2 = c2.getTime();
System.out.println(date2);// Sat Oct 10 10:10:59 CST 2020

//7. public void add(int field, int amout);
// 将某个字段对应的日期移动(增加或者减少)
c2.add(Calendar.DAY_OF_MONTH, 10);
System.out.println(c2.getTime());//Tue Oct 20 10:14:04 CST 2020

}
}

　　

如:
* 从键盘中录入一个年份,判断是平年还是闰年?
* 方式一: 判断这个年份能不能被4整除,并且不能被100整除, 或者是能被400整除. 特别麻烦
* 方式二: 只需要判断这个月的2月份有多少天, 如果是29天闰年, 如果是28天平年.

public class Demo05CalendarPractice {

public static void main(String[] args) {
// * 1. 创建Scanner对象,键盘中录入一个年份
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个年份");
int year = sc.nextInt();

// * 2. 创建Calendar对象, 使用getInstance方法
Calendar c = Calendar.getInstance();

// * 3. 设置输入年3月1日, set(int year, int month, int day);
c.set(year, 2, 1);// 设置成3月1日

// * 4. 将这个日历对象的中的天数,向前偏移一天,add(int field, int amount);
c.add(Calendar.DAY_OF_MONTH, -1);

// * 5. 获取这个月的天数.get(int Field);
int day = c.get(Calendar.DAY_OF_MONTH);

// * 6. 判断是29天,还是28天;
if(day == 29){
System.out.println(year + "年是闰年");
}else{
System.out.println(year + "年是平年");
}
}
}

　　

* System: 表示和系统相关的属性类,比如: 获取JDK的路径, 获取系统用户名,获取JDK的供应商等等...;
*
* 使用步骤:
* 1.由于System在java.lang包下面所以使用不需要导入包
* 2.创建对象,由于System的构造方法都被私有化了,所以不能创建对象
* 3.使用成员变量(字段),或者成员方法都是静态的内容;
*
* 常用的静态字段:
* System.in 标准的输入(标注的字节输入流);
* System.out 标准的输出
* System.err 用来输出错误或者异常信息,以红色字体展示, 快捷键: syse alt + / 回车
*
* 静态成员方法:
* public static void exit(int status);// 退出JVM虚拟机,0表示正常退出,非0异常退出
* public static long currentTimeMillis();// 获取当前运行在这一行的毫秒值
* public static void gc();// 建议JVM去做垃圾回收,不一定会回收.
* public static String getProperty(String key);// 获取指定的相关系统属性.
* key: 查API中System,先找到getProperties,通过这个方法可以找到所有的key


* Math: 可以用来表示复杂的数学运算相关的类,在java.lang包下面
*
* Math的使用步骤:
* 1. 导入包, 因为在lang包下所以不需要导入包
* 2. 创建对象, Math的构造方法都是私有的,所以不能创建对象
* 3. 使用静态成员变量,静态成员方法
*
* 静态的成员变量:
* Math.PI 表示一个π
*
* 静态的成员方法:

1. public static double abs(double a);// 返回double类型的绝对值
2. public static double ceil(double a);// 向上取整,以double类型返回
3. public static double floor(double a);// 向下取整,以double类型返回
4. public static double min(double a, double b);// 获取两个数的较小值
5. public static double max(double a, double b);// 获取两个数的较大值
6. public static double pow(double a, double b);// 返回a的b次方
7. public static double random();// 返回带正好的double值,该值大于等于0.0且小于1.0
8. public static long round(double a);// 返回a的四舍五入的值

 

框选快捷键:
alt + shit + a, 操作完成之后再按一次回到正常状态.

 

包装类:
* 如果直接操作基本数据类型,方式有限,只能进行基本的数学运算, 如果变成包装类之后,可以使用类中的方法,进行更加复杂的操作
* 比如: 可以将对应的数据存储到集合, 比如可以进行进制的转换;
* 如何将一个基本数据类型变成包装类,对应的类型有哪些?
* 基本数据类型 包装类类型(都在java.lang包下,全部都能直接使用)
* byte Byte
* short Short
* int Integer(特殊)
* long Long
* float Float
* double Double
* char Character(特殊)
* boolean Boolean


* 一个数字字符串如何和一个基本数据类型之间进行相互转换?
* 字符串转成基本数据类型:
* 方式:
* int num = Integer.parseInt(String str);
* 基本类型 变量名 = 包装类型.parseXxx(String str);// 和上面同理
*
*
* 基本数据类型转成字符串:
* 方式一: 基本数据类型 + "" ;// 推荐使用
* 扩展方式:
* 方式二: Integer的方法, Integer.toString(int num);
* 方式三(补充): String的方法, String.valueOf(int num);
*
* 注意:
* 只有数字类型对应的字符串,才能够转成对应基本数据类型

package cn.itcast.demo02;

public class Demo09StringPackAssign {

public static void main(String[] args) {

//字符串转成基本数据类型:
String str = "10";
int num = Integer.parseInt(str);
System.out.println(num + 10);

System.out.println(Double.parseDouble("60.66"));// 60.66
System.out.println("===========");

// 基本数据类型转成字符串的方式(三种)
// * 方式一: 基本数据类型 + "" ;// 推荐使用
System.out.println(10 + "" + 20);// 1020

// * 方式二: Integer的方法, Integer.toString(int num);
System.out.println(Integer.toString(100) + 200);// 100200

// * 方式三(补充): String的方法, String.valueOf(int num);
System.out.println(String.valueOf(50) + 50);// 5050
}
}

　　

 

* 自动装箱: 将基本数据类型自动封装引用数据类型
* 自动拆箱: 将引用数据类型拆箱成基本数据类型

package cn.itcast.demo02;

public class Demo10AutoPack {

public static void main(String[] args) {

//自动装箱: 将基本数据类型自动封装引用数据类型
Integer a = 10;
System.out.println(a);

Integer b = new Integer(20);
System.out.println(b.toString());
System.out.println("=========");

//自动拆箱: 将引用数据类型拆箱成基本数据类型
int c = new Integer(30);
System.out.println(c);

Integer d = 10;
d++;// 自动拆成 d = d + 1
System.out.println(d + 10);// 11+10 = 21
}
}

　　

正则表达式:
* 什么是正则表达式呢? 就是一个特殊的字符串, 用来匹配给定的字符串是否满足这个特殊的规则;
* 和正则表达式相关的方法(String类的方法):
* 1. public String[] split(String regex);
* 2. public boolean matches(String regex);
*
* 在正则表达式中英文句点(.), 有特殊含义,如果匹配需要使用 \\.
* 杠(\)在正则表达式中也有特殊含义表示,转移字符,用需要打印出 \, 需要写上: \\
* 加号(+), 字符+, 表示这个字符出现了一次或者多次

public class Demo11RegexExpresion {

public static void main(String[] args) {

//0.定义需要处理的字符串
//String content = "10086-10010-10000";
//String content = "10086.10010.10000";
String content = "10086,,,,,,10010,,,10000,,99999";

//1. public String[] split(String regex);
// 定义规则
//String regex = "-";
//String regex = "\\.";
String regex = ",+";

//2. 匹配
String[] array = content.split(regex);
System.out.println(Arrays.toString(array));

System.out.println("\\");// \
System.out.println("\\.");// \.
}
}

　　

例子:

package cn.itcast.demo02;
/*
* String的方法;
* public boolean matches(String regex);// 使用regex规则来检查调用的字符串是否满足这个规则.
* 
*/
public class Demo12MathesRegexExpresion {

public static void main(String[] args) {
//checkQQ();
//checkPhone();
checkEmail();
}

/*
* 匹配邮箱:
* 特点:
* xxx@xx.xx.xxx
* hello@qq.com.cn
* 1. @符号前面必须要有内容
* 2. @后面也有内容
* 3. 必须要有一个点. 可以有两个点
*/
public static void checkEmail(){

//1.定义邮箱
String email = "1111hahah@qq.com";

//2.定义规则
String regex = "\\w+@\\w+\\.\\w+(\\.\\w+)?";

//3.匹配邮箱
boolean isEmail = email.matches(regex);

if(isEmail){
System.out.println("是一个邮箱");
}else{
System.out.println("不是一个邮箱");
}

}

/*
* 匹配手机号:
* 特点:
* 1. 纯数字
* 2. 第一位必须是1
* 3. 第二位可以是: 3, 5, 7, 8
* 4. 共有11位
*/
public static void checkPhone(){
//1.定义手机号
String phone = "15838389438";

//2.定义规则
String regex = "[1][3578][0-9]{9}";

//3.匹配, 使用matches方法
boolean isPhone = phone.matches(regex);

//4.输出
if(isPhone){
System.out.println(phone + " 是一个手机号");
}else{
System.out.println(phone + " 不是一个手机号");
}
}

/*
* 匹配一个qq号:
* 特点:
* 1. 是一个纯数字
* 2. 开头不能是0
* 3. qq号的位数是 5到12位
*/
public static void checkQQ(){
//1. 定义一个qq号
String qq = "123456789";

//2.定义规则
String regex = "[1-9][0-9]{4,11}";

//3.匹配
boolean isQQ = qq.matches(regex);

if(isQQ){
System.out.println(qq + " 是一个qq号");
}else{
System.out.prin