标签：11 12 String System Date API println JavaSE out

JavaSE(12) - 常用API(下)

JDK7以前的时间相关类

Date类

如何创建日期对象

Date date = new Date(); //空参构造创建的对象,默认表示系统当前时间
Date date = new Date(指定毫秒值);//有参构造创建的对象,表示指定时间

如何修改时间对象中的毫秒值

setTime(毫秒值);

如何获取时间对象中的毫秒值

getTime();

练习:

需求1: 打印时间原点开始一年之后的时间
需求2: 定义任意两个Date对象, 比较一下哪个时间在前,哪个时间在后.

public static void main(String[] args) {
/*需求1: 打印时间原点开始一年之后的时间
需求2: 定义任意两个Date对象, 比较一下哪个时间在前,哪个时间在后.*/
        Date d = new Date(1000L*60*60*24*365);
        System.out.println(d);
        System.out.println("------------");
        //
        Random r = new Random();
        Date d1 = new Date(Math.abs(r.nextInt()));
        Date d2 = new Date(Math.abs(r.nextInt()));
        long time1 = d1.getTime();
        long time2 = d2.getTime();
        System.out.println(d1);
        System.out.println(d2);
        String s = time1 > time2 ? "d1在后面" : "d2在后面";
        System.out.println(s);
    }

P 170 SimpleDateFormat类

作用

格式化 : 把时间变成我们喜欢的格式

解析 : 把字符串表示的时间变成Date对象

**构造方法: ** 说明

public SimpleDateFormat() 构造一个对象, 使用默认格式

public SimpleDateFormat(String pattern) 构造一个对象, 使用指定格式

常用方法 说明

public final String format(Date date) 格式化 (日期对象 -> 字符串 )

public Date parse ( String source ) 解析 (字符串 -> 日期对象)

格式化

//默认格式
        SimpleDateFormat sdf1 = new SimpleDateFormat();
        //指定格式
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒 EE ");
        //创建日期对象
        Date date = new Date(0L);
        //把日期对象变成字符串并打印
        String f1 = sdf1.format(date);
        String f2 = sdf2.format(date);
        System.out.println(f1);
        System.out.println(f2);

解析

public static void main(String[] args) throws ParseException {
      
        //解析
        //创建日期字符串
        String date1 = "2023年11月11日 11时11分11秒";
        //创建sdf对象 参数为字符串的格式
    	//创建对象的格式要和字符串的格式一样
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
        //使用 parse方法 把字符串解析成Date对象
        Date date2 = sdf.parse(date1);
        System.out.println(date2);
    }

练习1:

2000-11-11 用字符串表示这个数据, 并转换为 : 2000年11月11日

 /*2000-11-11 用字符串表示这个数据,
          并转换为 : 2000年11月11日      */
        String s = "2000-11-11";
        //创建sdf对象
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        //解析成Date对象
        Date date = sdf.parse(s);
        //格式化Date对象成字符串
		//按照需求的格式
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy年MM月dd日");
        String s1 = sdf1.format(date);
        System.out.println(s1);

练习2 :

秒杀活动 : 2023年11月11日 0:0:0 ~ 2023年11月11日 0:10:0

小明下单的时间: 2023年11月11日 0:1:0

小红下单的时间: 2023年11月11日 0:11:0

用代码说明两个人有没有参加上秒杀活动.

//字符串
        String order = "2023年11月11日 00:01:00";//小明下单的时间
        String start = "2023年11月11日 0:0:0";//秒杀开始时间
        String end = "2023年11月11日 0:10:0";//秒杀结束时间

        //解析成Date对象
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        Date DateOrder = sdf.parse(order);
        Date DateStart = sdf.parse(start);
        Date DateEnd = sdf.parse(end);
        //获取时间数
        long orderTime = DateOrder.getTime();
        long startTime = DateStart.getTime();
        long endTime = DateEnd.getTime();
        //判断是否在秒杀时间段
        if (orderTime > startTime && orderTime < endTime) {
            System.out.println("秒杀成功");
        } else System.out.println("秒杀失败");

P171 Calendar 日历类

Calendar 的常用方法

public static Calendar getlnstance() 获取当前时间的日历对象

public final Date getTime() 获取日期对象

public final setTime(Date date) 给日历设置日期对象

public long getTimeInMillis() 拿到时间亳秒值

public void setTimeInMillis(long millis) 给日历设置时间毫秒值

public int get(int field) 取日期中的某个字段信息

public void set (int field., int value) 修改日历的某个字段信息

public void add(int field,int amount) 为某个字段增加/减少指定的值

**细节1. **

Calendar类是一个抽象类, 不能直接new, 而是通过一个静态方法获取子类对象

细节2.

月份范围 : 0~11 如果获取0,实际是1月

星期 : 星期日是一周的第一天.

1(星期日) 2(星期一) 3(星期二) 4(星期三) 5(星期四) 6(星期五) 7(星期六)

  public static void main(String[] args) {
        //创建Calendar对象
        Calendar cal = Calendar.getInstance();
        //获取一些属性
        int year = cal.get(Calendar.YEAR);
        //月份要加一
        int month = cal.get(Calendar.MONTH) + 1;
        int date = cal.get(Calendar.DATE);
        //周日是第一天
        int week = cal.get(Calendar.DAY_OF_WEEK);
        //调用方法转换为星期
        String s = castWeek(week);
        System.out.println(year + "," + month + "," + date + "," + s);
    }
    //输入对应的数字符合星期几  ***查表法***   创建数组,使数组元素和索引形成对应关系.====
    //1(星期日)	2(星期一)	3(星期二)	4(星期三)	5(星期四)	6(星期五)	7(星期六)
    public static String castWeek(int number){
        String[] week = {"", "星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"};
        //传递的形参就是索引, 再返回数组元素
        return week[number];
    }

总结

Calendar表示什么？

表示一个时间的日历对象

2.如何获取对象

通过静态方法 getInstance()方法获取对象

常见方法：

setXxx : 修改

getXxx : 获取

add : 在原有的基础上进行增加或者减少

细节点:

日历类中月份的范围：0〜11

曰历类中星期的特点：星期日是一周中的第一天

P 172 JDK8的时间类

1, Date类

ZoneId: 时区类

  //获得所有时区
        Set<String> availableZoneIds = ZoneId.getAvailableZoneIds();
//        System.out.println(availableZoneIds);
        System.out.println(availableZoneIds.size());//打印集合长度 600
        //获得系统当前时区 ->对象
        ZoneId zoneId = ZoneId.systemDefault();
        System.out.println(zoneId);
        //获取指定一个时区 字符串->对象
        ZoneId of = ZoneId.of("Asia/Shanghai");
        System.out.println(of);

Instant : 时间戳类

static Instant now() 获取当前时间的Instant对象（标准时间)

static Instant ofXxxx(long epochMilli) 根据（秒/毫秒/纳秒）获取工Instant对象

ZonedDateTime atZone(ZoneId zone) 指定时区

boolean isXxx(工nstant otherlnstant) 判断系列的方法

Instant minusXxx(long millisToSubtract) 减少时间系列的方法

Instant plusXxx(long millisToSubtract) 增加时间系列的方法

 //获取当前日期,时间对象
        Instant now = Instant.now();
        System.out.println(now);
        //获得指定日期时间对象
        Instant instant1 = Instant.ofEpochMilli(1000L);//时间原点后1秒
        System.out.println(instant1);
        //指定时区  不是静态方法,只能用对象去调用
        //就是显示该时区的日期时间
        ZonedDateTime zonedDateTime = Instant.now().atZone(ZoneId.systemDefault());
        System.out.println(zonedDateTime);//2023-12-14T13:56:07.291154700+08:00[Asia/Shanghai]
        //判断系列的方法
        boolean after = instant1.isAfter(now);//是否在参数时间后
        boolean before = instant1.isBefore(now);//是否在参数时间前
        System.out.println(after);//false
        System.out.println(before);//true
        //减少/增加时间系列的方法
        Instant instant2 = Instant.ofEpochMilli(10000000L);
        Instant instant3 = instant2.minusSeconds(10000000L);//减掉时间
        System.out.println(instant3);

ZoneDateTime : 带时区的时间类

static ZonedDateTime now() 获取当前时间ZonedDateTime对象

static ZonedDateTime ofXxxx(...) 获取指定时间ZonedDateTime对象

ZonedDateTime withXxxx(时间) 修改时间的方法

ZonedDateTime minusXxx(时间) 减少时间的方法

ZonedDateTime plusXxx(时间) 增加时间的方法

细节

JDK8新增的时间对象都是不可变的, 如果我们修改, 减少,增加了时间, 那么调用者是不会发生改变的, 而是产生了一个新的时间.

 //获取当前时间ZonedDateTime对象 带时区的时间
        ZonedDateTime now = ZonedDateTime.now();
        System.out.println(now);
        //获取指定时间ZonedDateTime对象
        ZonedDateTime shanghai = ZonedDateTime.of(2023, 1, 1, 12, 01, 20, 0, ZoneId.of("Asia/Shanghai"));
        System.out.println(shanghai);
        //修改时间的方法
        ZonedDateTime d1840 = now.withYear(1840);
        System.out.println(d1840);
        //减少时间的方法
        ZonedDateTime d20b = now.minusYears(20L);
        System.out.println(d20b);

2, 日期格式化类:SimpleDateFormat

DateTimeFormatter类用于时间的格式化和解析

static DateTimeFormatter ofPattern(格式) 获取格式对象

String format(时间对象) 按照指定方式格式化

  //获取带时区的时间对象
        ZonedDateTime Time = Instant.now().atZone(ZoneId.of("Asia/Shanghai"));
        //获取格式对象        ***年月日 时分秒 星期 上下午***
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss EE a");
        //按照指定方式格式化
        String format = dtf.format(Time);
        System.out.println(format);

P 173 - 3,日历类: Calendar

LocalDate : 年,月,日

LocalTime : 时,分,秒 (只关注时间, 比较精确)

LocalDateTime : 年,月,日,时,分,秒

MonthDay : 月日类, (只有日和月,比如生日)

和上面的日历类用法差不多

4, 工具类

Duration : 时间间隔 (秒, 纳秒)

Period : 时间间隔 (年,月,日)

ChronoUnit : 时间间隔 (所有单位)

public class ChronoUnitDemo {
    public static void main(String[] args) {
        //现在的日期
        LocalDate now = LocalDate.now();
        //生日
        LocalDate birthDay = LocalDate.of(2000, 1, 1);
        //计算时间间隔 静态方法
        System.out.println(ChronoUnit.YEARS.between(birthDay, now) + "年");
        System.out.println(ChronoUnit.MONTHS.between(birthDay, now) + "月");
        System.out.println(ChronoUnit.DAYS.between(birthDay, now) + "天");
        System.out.println("------------");
        long days = ChronoUnit.DAYS.between(birthDay, now);
        System.out.println(getChrono(days));
        
    }
    //输出大概过了多少年月日
    public static String getChrono(long date) {
        long years = date / 365;
        long months = date % 365 / 30;
        long days = date % 365 % 12;
        return " " + years + "年" + months + "月" + days + "天";
    }
}

P174 包装类

用一个对象把数据包起来

包装类就是基本数据类型所对应的对象
JKD5后对包装类新增了自动装箱/拆箱功能

如何获取包装类对象: 不需要new,不需要调用方法,直接赋值即可

 public static void main(String[] args) {
        //Integer的自动装箱/拆箱
        //自动装箱
        Integer i1 = 10;
        //自动拆箱
        Integer i2 = new Integer(20);
        int int3 = i2;
        //直接计算就行
        Integer i4 = i1 + i2;
    }

进制转换

public static Integer.toXxxString(int i)

//进制转换
        //DEC -> BIN二进制
        System.out.println(Integer.toBinaryString(100));
        //DEC -> OCT八进制
        System.out.println(Integer.toOctalString(100));
        //DEC -> HEX十六进制
        System.out.println(Integer.toHexString(100));
        //将字符串类型的整数转成int类型
        int anInt = Integer.parseInt("100");
        System.out.println(anInt + 1);//101
        //将字符串类型转成boolean类型
        String s = "true";
        boolean b = Boolean.parseBoolean(s);
        if (b) {
            System.out.println("b is boolean type.");
        }

改进键盘录入

当我们使用next, nextInt, nextDouble在接收数据时, 遇到空格, 回车, 制表符时就停止了,但是我们想要的是接收一整行的数据, 所以我们要想键盘录入, 不管什么类型, 统一使用nextLine,他的特点是遇到回车才停止

 //改进键盘录入
        Scanner sc = new Scanner(System.in);
        System.out.println("输入一个整数:");
        //nextLine,他的特点是录入一整行数据,遇到回车才停止.
        String s1 = sc.nextLine();
        //类型转换
        String regex = "\\d+";
        boolean matches = s1.matches(regex);
        //判断只能输入整数
        if (matches){
            int i = Integer.parseInt(s1);
            System.out.println(i);
        }else System.out.println("只能输入整数.");

P175 综合练习

1.键盘录入

键盘录入一些1~100之间的整数, 平添加到集合中. 直到集合中所有数据和超过200为止.

public static void main(String[] args) {
        //创建集合
        ArrayList<Integer> arrayList = new ArrayList<>();
        //获得随机数
        Random r = new Random();

        while (getSum(arrayList) <= 200) {
            int i = r.nextInt(100) + 1;
            arrayList.add(i);
            System.out.println(i);
        }
        System.out.println("集合的总和:"+getSum(arrayList));
    }

    //计算集合中数据的总和方法
    public static int getSum(ArrayList<Integer> list) {
        //创建总和变量
        int sum = 0;
        //遍历集合
        for (int i = 0; i < list.size(); i++) {
            //得到每个元素, 并累加
            Integer integer = list.get(i);
            sum += integer;
        }
        return sum;
    }

2.算法水题 parseInt

自己实现parseInt方法的效果, 将字符串形式的数据转成整数.

要求:

字符串中只能是数字不能是其它字符

最少一位, 最多10位

0不能开头

public static void main(String[] args) {
        String s = "123456789";
        int i = parseInt(s);
        System.out.println(i);
    }
    //将字符串形式的数据转成整数     "123" -> 1 2 3
    public static int parseInt(String s){
        //结果int变量
        int result = 0;
        //遍历字符串
        for (int i = 0; i < s.length(); i++) {
            //获得每一个字符
            char c = s.charAt(i);
            //"0" = 48 把char字符转换成int
            int i1 = c - 48;
            //计算结果
            result = result * 10 + i1;
        }
        return result;
    }

3.算法水题 toBinaryString

定义一个方法自己实现toBinaryString方法的效果, 将一个十进制整数转成字符串表示的二进制.

提示: 除基取余法

不断的除以基数 (几进制,基数就是几) 得到余数, 直到商为零, 再将余数倒着拼起来即可.

2|6

2|3商---0余

2|1商---1余

|0商---1余

public static void main(String[] args) {
        int i = 100;
        System.out.println(toBinaryString(i));
    }

    //DEC -> BIN    int -> String
    public static String toBinaryString(int i) {
        //结果变量
        String bin = "";
        while (i != 0) {
            int r = i % 2;//Remainder 得到 余数
            i /= 2;//Quotient 得到 商
            //倒着拼接字符串
            bin = r + bin;
        }
        return bin;
    }

4.算法水题活了多少天

请使用代码实现计算你活了多少天, 用JKD7和JKD两种方式完成.

public static void main(String[] args) throws ParseException {
        //由字符串解析成Date对象
        int year = 1985;
        System.out.println(isLeapYearJ7(year));//JDK7方法
        System.out.println("-----------");
        System.out.println(isLeapYearJ8(year));//JDK8方法

    }

    //isLeapYear JDK7
    public static boolean isLeapYearJ7(int year) throws ParseException {
        //闰年有2月29日,平年2月29日就是3月1日,
        String date = year + "-02-29";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date parse = sdf.parse(date);
        //再格式化成字符串
        String format = sdf.format(parse);
        //格式化的字符串
        System.out.println(format);
        //原始的字符串
        System.out.println(date);
        //两个字符串比较是否内容相同,相同就是闰年
        return date.equals(format);
    }

    //isLeapYear JDK8
    public static boolean isLeapYearJ8(int year) {
        //获得当前年份和下一年的1月1日的对象,
        LocalDate ofYear = LocalDate.of(year, 1, 1);
        LocalDate of = LocalDate.of(year + 1, 1, 1);
        //计算这两个对象间隔多少天
        long days = ChronoUnit.DAYS.between(ofYear, of);
        //如果是366天,当前年份就是闰年
        return days == 366 ? true : false;
    }

5.算法水题闰年

判断任意一年是闰年还是平年

要求: 用JKD7和JKD两种方式判断

提示: 二月有29天是闰年或者一年有366天是闰年

public static void main(String[] args) throws ParseException {
        //JDK7
        //现在的时间
        Date now = new Date();
        System.out.println(now);
        //生日的时间
        String s = "1981,2,26 06:00:00";
        //解析字符串得到时间对象
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy,MM,dd HH:mm:ss");
        Date birthday = sdf.parse(s);
        System.out.println(birthday);
        //获得对象的毫秒值,再相减得到天数
        long nowTime = now.getTime();
        long birthdayTime = birthday.getTime();
        long days = (nowTime - birthdayTime) / 1000 / 60 / 60 / 24;
        System.out.println(days+"天");

        System.out.println("--------------");
        //JDK8
        LocalDate now1 = LocalDate.now();
        LocalDate of = LocalDate.of(1981, 2, 26);
        long between = ChronoUnit.DAYS.between(of, now1);
        System.out.println(between+"天");
    }

标签：11,12,String,System,Date,API,println,JavaSE,out
From： https://www.cnblogs.com/lg369/p/17967029

JavaSE(12) - 常用API(下)

JavaSE(12) - 常用API(下)

JDK7以前的时间相关类

Date类

P 170 SimpleDateFormat类

作用

P171 Calendar 日历类

P 172 JDK8的时间类

1, Date类

2, 日期格式化类:SimpleDateFormat

P 173 - 3,日历类: Calendar

4, 工具类

P174 包装类

进制转换

改进键盘录入

P175 综合练习

1.键盘录入

2.算法水题 parseInt

3.算法水题 toBinaryString

4.算法水题活了多少天

5.算法水题闰年

相关文章

赞助商

阅读排行

JavaSE(12) - 常用API(下)

JavaSE(12) - 常用API(下)

JDK7以前的时间相关类

Date类

P 170 SimpleDateFormat类

作用

P171 Calendar 日历类

P 172 JDK8的时间类

1, Date类

2, 日期格式化类:SimpleDateFormat

P 173 - 3,日历类: Calendar

4, 工具类

P174 包装类

进制转换

改进键盘录入

P175 综合练习

1.键盘录入

2.算法水题 parseInt

3.算法水题 toBinaryString

4.算法水题 活了多少天

5.算法水题 闰年

相关文章

赞助商

阅读排行

4.算法水题活了多少天

5.算法水题闰年