目录标题
毫秒值的概念和作用
毫秒:千分之一秒 1000毫秒=1秒
特定瞬间:一个时间点
毫秒值的作用:可以对时间和日期进行计算
使用场景
例如:计算2099-01-03到2088-01-01中间一共有多少天
解决方案:
可以将日期转换为毫秒值进行计算,计算完毕,在把毫秒值转换为日期
把日期转换为毫秒
当前日期:2088-01-01
时间原点:1970年1月1日00:00:00(英国格林威治时间)
计算当前日期到时间原点之间一共经历了多少毫秒
package test.code.src.cn.itcast.day11.demo08;
public class t1{
public static void main(String[] args) {
//获取当前系统时间到1970年1月1日0分0秒0毫秒经历了多少毫秒
System.out.println(System.currentTimeMillis());//1584931420442L
}
}
把毫秒转换为日期
1天 =24 *60 *60 = 86400秒 = 86400 * 1000 = 86400000毫秒
注意事项:
中国属于东八区,会把时间增加8个小时
Date类的构造方法
import java.util.Date;
public class t1{
public static void main(String[] args) {
demo03();
}
private static void demo03() {
Date date = new Date();
//getTime()从原点到现在时间点的毫秒值,相当于System.currentTimeMillis()
long time = date.getTime();
System.out.println(time);//1584932663630
}
private static void demo02() {
//Date(long date):传递毫秒值,把毫秒值转换为Date日期
Date date = new Date(0L);
System.out.println(date);//Thu Jan 01 08:00:00 CST 1970
}
private static void demo01(){
//Date()获取当前系统的日期和时间
Date date = new Date();
System.out.println(date);//Mon Mar 23 10:58:11 CST 2020
}
}
DateFormat类和SimpleDateFormat
DateFormat:是日期/时间格式化子类的抽象类
DateFormat类是一个抽象类,无法直接创建对象使用,可以使用DateFormat类的
子类SimpleDateFormat
作用:
格式化(日期->文本) 解析(文本->日期)
成员方法
String format(Date date) 按照指定的模式,把Date日期,格式化为符合模式的字符串
Date parse(String source) 把符合模式的字符串,解析为Date日期
构造方法
常用的格式规则为:
写对应的模式,会把模式替换成对应的日期和时间
例如"yyyy-MM-dd HH:mm:ss"
注意事项:
模式中的字母不能改变,连接模式的符号可以改变
例如"yyyy年MM月dd日 HH时mm分ss秒"
DateFormat类的format方法和parse方法
format方法把日期格式转化为文本的使用步骤:
1.创建SimpleDateFormat对象,构造方法中传递指定的模式
2.调用SimpleDateFormat对象中的方法format,按照构造方法中的指定模式,把Date日期格式转化为符合模式的字符串
import java.text.SimpleDateFormat;
import java.util.Date;
public class t1 {
public static void main(String[] args) {
demo01();
}
private static void demo01() {
//使用DateFormat类中的format,把日期格式化为文本
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date date = new Date();
String format = sdf.format(date);
System.out.println(date); //Mon Mar 23 12:51:32 CST 2020
System.out.println(format); //2020-03-23 12:51:32
}
}
使用DateFormat类中的方法parse,把文本解析为日期
使用步骤:
1.创建SimpleDateFormat对象,构造方法中传递指定的模式
2.调用SimpleDateFormat对象中的方法parse,把符合构造方法中模式的字符串,解析为Date日期
注意事项:
DateFormat源码中parse方法声明了一个异常ParseException(解析异常)
如果字符串和构造方法的模式不一样,那么程序就会抛出此异常
调用了一个抛出异常方法,就必须处理这个异常,要么继续抛出,要么try catch捕获异常
这里使用与python 中的 try …except相同
Calender类介绍
Calendar类是一个抽象类,里面提供了很多操作日历字段的方法
Calender类无法直接创建对象使用,里面有一个静态方法叫getInstance(),该方法返回了Calendar类的子类对象
static Calendar getInstance() 使用默认时区和语言环境获得一个日历
import java.util.Calendar;
public class t1 {
public static void main(String[] args){
Calendar c = Calendar.getInstance();//多态
System.out.println(c);//java.util.GregorianCalendar[time=1584973265154,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id="Asia/Shanghai",offset=28800000,dstSavings=0,useDaylight=false,transitions=19,lastRule=null],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2020,MONTH=2,WEEK_OF_YEAR=13,WEEK_OF_MONTH=4,DAY_OF_MONTH=23,DAY_OF_YEAR=83,DAY_OF_WEEK=2,DAY_OF_WEEK_IN_MONTH=4,AM_PM=1,HOUR=10,HOUR_OF_DAY=22,MINUTE=21,SECOND=5,MILLISECOND=154,ZONE_OFFSET=28800000,DST_OFFSET=0]
}
Calendar类的常用成员方法
Calendar类常用的成员方法
成员方法的参数
int field:日历类的字段,可以使用Calendar类的静态成员变量获取
get方法使用演示
import java.util.Calendar;
public class t1 {
public static void main(String[] args){
domo01();
}
private static void domo01() {
Calendar c = Calendar.getInstance();
int year = c.get(Calendar.YEAR);
System.out.println(year);//2020
int month = c.get(Calendar.MONTH);
System.out.println(month); //03 西方的月份0-11中国的:1-12
int date = c.get(Calendar.DATE);
System.out.println(date);//23
}
}
set方法使用演示
import java.util.Calendar;
public class t1 {
public static void main(String[] args){
domo01();
}
private static void domo01() {
Calendar c = Calendar.getInstance();
//设置年尾9999
c.set(Calendar.YEAR,9999);
int year = c.get(Calendar.YEAR);
System.out.println(year);//9999
//设置月为9月
c.set(Calendar.MONTH,9);
//设置天为9日
c.set(Calendar.DATE,9);
//同时设置年月日,可以使用set的重载方法
c.set(8888,88,9);
}
add方法使用演示:把指定的字段增加/减少指定的值
import java.util.Calendar;
public class t1 {
public static void main(String[] args){
domo01();
}
private static void domo01() {
Calendar c = Calendar.getInstance();
//把年增加两年
c.add(Calendar.YEAR,2);
//把月份减少3个月
c.add(Calendar.MONTH,-3);
}
}
getTime方法的使用演示:把日历类转换为日期对象
import java.util.Calendar;
import java.util.Date;
public class t1 {
public static void main(String[] args){
domo01();
}
private static void domo01() {
Calendar c = Calendar.getInstance();
Date date = c.getTime();
System.out.println(date);//Mon Mar 23 16:40:12 CST 2020
}
}
System类的常用方法
currentTimeMillis返回以毫秒值为单位的当前时间
主要用途是:用来测试我们程序的效率
验证for循环打印数组1-9999所需要的时间(毫秒)
import java.util.Calendar;
import java.util.Date;
public class t1 {
public static void main(String[] args){
long start = System.currentTimeMillis();
domo01();
long end = System.currentTimeMillis() - start;
System.out.println("所需要时间"+end+"秒");//所需要时间73秒
}
private static void domo01() {
for (int i = 1; i < 10000; i++) {
System.out.println(i);
}
}
}
arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 将数组中指定的数据拷贝待另一个数组中
参数:
src - 源数组。
srcPos - 源数组中的起始位置。
dest - 目标数组。
destPos - 目标数据中的起始位置。
length - 要复制的数组元素的数量。
将src数组[1,2,3,4,5]中前3个元素,复制到dest[6,7,8,9,10]数组的前3个位置上
import java.util.Arrays;
import java.util.Calendar;
import java.util.Date;
public class t1 {
public static void main(String[] args){
demo02();
}
private static void demo02() {
//定义原数组
int[] src = {1,2,3,4,5};
//定义目标数组
int[] dest = {6,7,8,9,10};
//使用System类中的arraycopy
System.arraycopy(src,0,dest,0,3);
System.out.println("复制后:"+Arrays.toString(dest));//[1, 2, 3, 9, 10]
}
}
StringBuilder类的原理
StringBuilder类的使用场景是什么?
字符串是常量他们的值在创建之后不能更改.
String源码:
字符串的底层就是一个被final修饰的数组.当进行字符串的相加是,内存就会出现多个字符串对象,占用空间多,效率低下.
但是StringBuilder类字符串缓冲区是可以支持可变的字符串
可以提供字符串的操作效率(类似于一个长度可变的字符串)底层也是一个数组
但是没有被final修饰,可变改变长度
StringBuilder的构造方法
import java.util.Arrays;
public class t1 {
public static void main(String[] args){
StringBuilder bu1 = new StringBuilder();
System.out.println("bu1:"+bu1);//bu1:
//待字符串的构造方法
StringBuilder bu2 = new StringBuilder("abc");
System.out.println("bu2:"+bu2);//bu2:abc
}
}
常用方法
StringBuilder的append()方法
package test.code.src.cn.itcast.day11.demo08;
import java.util.Arrays;
public class t1 {
public static void main(String[] args){
//创建StringBuilder对象
StringBuilder bu = new StringBuilder();
//使用append方法添加数据
//以后使用append无需接收返回值
bu.append("abc");
bu.append("123");
bu.append("众数");
System.out.println(bu); //abc123众数
//还可以使用链式编程
bu.append("abc").append("123").append("众数");
System.out.println(bu); //abc123众数
}
}
StringBuilder的toString方法
import java.util.Arrays;
public class t1 {
public static void main(String[] args){
//String->StringBuilder
String str = "hello";
System.out.println("str:"+str);//str:hello
StringBuilder bu = new StringBuilder(str);
//往StringBuilder中添加数据
bu.append("world");
System.out.println("bu:"+bu);//bu:helloworld
//StringBuilder ->String
String s = bu.toString();
System.out.println("s:"+s);//s:helloworld
}
}
包装类的概念
基本数据类型,使用起来非常方便,但是没有对应的方法来操作这些进本类型的数据
可以使用一个类,把基本类型的数据装起来,在类中定义一些方法,这个类叫做包装类
我们可以使用类中的方法来操作这些基本类型的数据
说白了就是使用一个类把对应的数据类型给装起来
包装类_装箱与拆箱
装箱:把基本类型的数据,包装到包装类中(基本类型的数据->包装类)
import java.util.Arrays;
public class t1 {
public static void main(String[] args){
//装箱(基本类型数据->包装类)
//构造方法
Integer in1 = new Integer(1); //有横说明方法过时
System.out.println(in1); //1 重写了toString方法
Integer in2 = new Integer("1");
System.out.println(in2); //1
//静态方法
Integer in3 = Integer.valueOf(1);
System.out.println(in3);//1
Integer in4 = Integer.valueOf("1");
System.out.println(in4);//1
}
}
拆箱:在包装类中取出基本类的数据(包装类->基本类型的数据)
import java.util.Arrays;
public class t1 {
public static void main(String[] args){
//装箱(基本类型数据->包装类)
//静态方法
Integer in3 = Integer.valueOf(1);
System.out.println(in3);//1
//拆箱(包装类->基本类型数据)
int i = in3.intValue();
System.out.println(i); //1
}
}
包装类_自动装箱与自动拆箱
自动装箱与自动拆箱:基本类型的数据和包装类之间可以自动的相互转换
import java.util.Arrays;
public class t1 {
public static void main(String[] args){
//自动装箱:直接把int类型的数据复制给包装类
Integer in = 1;
//自动拆箱:in是包装类,无法直接参与运算,可以自动转换为int,在进行计算
in = in+2;
ArrayList<Integer> list = new ArrayList<>();
//ArrayList集合无法直接存储整数,但是可以存储Integer包装类
list.add(1);//这里隐含了一个自动装箱int->Integer
int a = list.get(0); //自动拆箱 Integer->int
}
}
包装类_基本类型与字符串类型之间
基本类型与字符串类型之间的相互转换
基本类型->字符串(String)
1.基本类型的值+" "最简单的方法
2.包装类的静态方法toString(参数),不是Object类的toString()重载
3.String类的静态方法valueOf(参数)
字符串->基本类型
使用包装类的静态方法parseXXX(“数组类型的字符串”)
public class t1 {
public static void main(String[] args){
//基本数据类型->String
int i1 = 100;
String s = i1 + ""; //经常使用
System.out.println(s+200); //100200
String s2 = Integer.toString(100);
System.out.println(s2+200); //100200
String s3 = String.valueOf(100);
System.out.println(s3+200); //100200
//String->基本数据类型
int i = Integer.parseInt("11");
System.out.println(i-1);//10
}
}