日期时间类常见API以及包装类

Surpass余sheng军

已于 2023-05-20 22:57:17 修改

阅读量471

点赞数

分类专栏： JavaSE 文章标签： java jvm servlet

于 2023-03-01 15:49:16 首次发布

By Mr.Gao

本文链接：https://blog.csdn.net/weixin_53622554/article/details/129275485

版权

JavaSE 专栏收录该内容

56 篇文章 6 订阅

订阅专栏

第一章：日期与时间

一.Date类

package com.gch.d1_date;

import java.util.Date;

/**
   目标:学会使用Date类处理时间,获取时间的信息
 */
public class DateDemo1 {
    public static void main(String[] args) {
        // 1.创建一个Date类的对象:代表系统此刻日期时间对象
        Date d = new Date();
        System.out.println(d); // Wed Mar 01 10:04:09 CST 2023

        // 2.获取时间毫秒值
        long time = d.getTime();
        System.out.println(time); // 1677636249346
//        long time1 = System.currentTimeMillis();
//        System.out.println(time1);

        System.out.println("-----------------------");
        // 请计算当前时间往后走1小时121秒之后的时间是多少

        // 1.得到当前时间
        Date d1 = new Date();
        System.out.println(d1); // Wed Mar 01 10:04:09 CST 2023

        // 2.当前时间往后走1小时121秒
        long time2 = System.currentTimeMillis();
        time2 += (60 * 60 + 121) * 1000;

        // 3.把时间毫秒值转换成对应的日期对象
//        Date d2 = new Date(time2);
//        System.out.println(d2);

        Date d3 = new Date();
        // 设置日期对象的时间为当前时间毫秒值对应的时间
        d3.setTime(time2);
        System.out.println(d3); // Wed Mar 01 11:06:10 CST 2023
    }
}

二.SimpleDateFormat类

package com.gch.d2_simpledateformat;

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

/**
    目标:SimpleDateFormat简答日期格式化类的使用
    格式化时间
    解析时间
 */
public class SimpleDateFormatDemo1 {
    public static void main(String[] args) {
        // 1.日期对象
        Date d = new Date();
        System.out.println(d); // Sat Feb 25 18:08:35 CST 2023

        // 2.格式化这个日期对象(指定最终格式化的形式)  
        // EEE:代表星期几 a:代表是上午还是下午 
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss EEE a");
        // 3.开始格式化日期对象称为喜欢的字符串形式
        String rs = sdf.format(d);
        System.out.println(rs); // 2023年02月25日 18:08:35 星期六 下午
        System.out.println("-----------------------");

        // 4.格式化时间毫秒值
        // 需求:请问121秒后的时间是多少
        long time = System.currentTimeMillis() + 121 * 1000;
        String rs2 = sdf.format(time);
        System.out.println(rs2); // 2023年02月28日 14:34:35 星期二 下午
    }
}

package com.gch.d2_simpledateformat;

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

public class SimpleDateFormatDemo2 {
    public static void main(String[] args) throws ParseException {
        // 目标:学会使用SimpleDateFormat解析字符串时间成为日期对象
        System.out.println("------解析字符串时间-------");
        // 案例:请计算出2021年08月06日11点11分11秒,往后走2天14小时49分06秒后的时间是多少
        // 1.把字符串时间拿到程序中来
        String dataStr = "2021年08月06日 11:11:11";

        // 2.把字符串时间解析成日期对象(本节的重点):形式必须与被解析时间的格式完全一样,否则运行时解析报错!
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:s");
        Date d = sdf.parse(dataStr);

        // 3.往后走2天 14小时 49分 06秒
        long time = d.getTime() + (2L * 24 * 60 * 60 + 14 * 60 * 60 + 49 * 60 + 6) * 1000;

        // 4.格式化这个时间毫秒值就是结果
        System.out.println(sdf.format(time)); // 2021年08月09日 02:00:17
    }
}

案例：

package com.gch.d2_simpledateformat;

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

public class SimpleDateFormatTest3 {
    public static void main(String[] args) throws ParseException {
        // 1.开始和结束时间
        String startTime = "2021-11-11 00:00:00";
        String endTime = "2021-11-11 00:10:00";

        // 2.小贾  小皮
        String xiaoJia = "2021-11-11 00:03:47";
        String xiaoPi = "2021-11-11 00:10:11";

        // 3.解析他们的字符串时间为日期对象
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date d1 = sdf.parse(startTime);
        Date d2 = sdf.parse(endTime);
        Date d3 = sdf.parse(xiaoJia);
        Date d4 = sdf.parse(xiaoPi);

        if(d3.after(d1) && d3.before(d2)){
            System.out.println("小贾秒杀成功,可以发货了!");
        }else{
            System.out.println("小贾秒杀失败!");
        }

        if(d4.after(d1) && d4.before(d2)){
            System.out.println("小皮秒杀成功,可以发货了!");
        }else{
            System.out.println("小皮秒杀失败!");
        }
    }
}

三. Calendar [日历]

package com.gch.d3_calendar;

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

/**
 * 目标：日历类Calendar的使用,可以得到更加丰富的信息。
 * <p>
 * Calendar代表了系统此刻日期对应的日历对象。
 * Calendar是一个抽象类，不能直接创建对象。
 * Calendar日历类创建日历对象的语法：
 * Calendar rightNow = Calendar.getInstance();
 * Calendar的方法：
 * 1.public static Calendar getInstance(): 返回一个日历类的对象。
 * 2.public int get(int field)：取日期中的某个字段信息。
 * 3.public void set(int field,int value)：修改日历的某个字段信息。
 * 4.public void add(int field,int amount)：为某个字段增加/减少指定的值
 * 5.public final Date getTime(): 拿到此刻日期对象。
 * 6.public long getTimeInMillis(): 拿到此刻时间毫秒值
 * 小结：
 *     记住。
 */
public class CalendarDemo{
    public static void main(String[] args) {
        // 1、拿到系统此刻日历对象
        Calendar cal = Calendar.getInstance();
        System.out.println(cal);

        // 2、获取日历的信息:public int get(int field)：取日期中的某个字段信息。
        int year = cal.get(Calendar.YEAR);
        System.out.println(year); // 2023

        int mm = cal.get(Calendar.MONTH) + 1;
        System.out.println(mm); // 5

        int days = cal.get(Calendar.DAY_OF_YEAR) ;
        System.out.println(days); // 140

        // 3、public void set(int field,int value)：修改日历的某个字段信息。
        //                    要修改的字段  修改后的值
//        cal.set(Calendar.HOUR, 12);
//        System.out.println(cal);

        // 4.public void add(int field,int amount)：为某个字段增加/减少指定的值
        // 请问64天后是什么时间
        cal.add(Calendar.DAY_OF_YEAR , 64);
        cal.add(Calendar.MINUTE , 59);

        //  5.public final Date getTime(): 拿到此刻日期对象。
        Date d = cal.getTime();             // 2023年07月23日  22:32:30  星期日 下午
        System.out.println(new SimpleDateFormat("yyyy年MM月dd日  HH:mm:ss  EEE a").format(d));

        //  6.public long getTimeInMillis(): 拿到此刻时间毫秒值
        long time = cal.getTimeInMillis();
        System.out.println(time); // 1690122750222
    }
}

第二章：JDK8新增日期类

四. LocalTime /LocalDate / LocalDateTime

package com.gch.d4_jdk8_time;
import java.time.LocalDate;
import java.time.Month;

public class Demo01LocalDate {
    public static void main(String[] args) {
        // 1、获取本地日期对象。
        LocalDate nowDate = LocalDate.now();
        System.out.println("今天的日期:" + nowDate); // 今天的日期:2023-05-20

        int year = nowDate.getYear();
        System.out.println("year:" + year); // year:2023


        int month = nowDate.getMonthValue();
        System.out.println("month:" + month); // month:5

        int day = nowDate.getDayOfMonth();
        System.out.println("day:" + day); // day:20

        //当年的第几天
        int dayOfYear = nowDate.getDayOfYear();
        System.out.println("dayOfYear:" + dayOfYear); // dayOfYear:140

        //星期
        System.out.println(nowDate.getDayOfWeek());// SATURDAY
        System.out.println(nowDate.getDayOfWeek().getValue()); // 6

        //月份
        System.out.println(nowDate.getMonth()); // MAY
        System.out.println(nowDate.getMonth().getValue()); // 5

        System.out.println("------------------------");
        LocalDate bt = LocalDate.of(1991, 11, 11);
        System.out.println(bt);//直接传入对应的年月日 // 1991-11-11
        System.out.println(LocalDate.of(1991, Month.NOVEMBER, 11));//相对上面只是把月换成了枚举
    }
}

package com.gch.d4_jdk8_time;

import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.Month;

public class Demo02LocalTime {
    public static void main(String[] args) {
        // 1、获取本地时间对象。
        LocalTime nowTime = LocalTime.now();
        System.out.println("今天的时间:" + nowTime); // 今天的时间:21:57:50.714

        int hour = nowTime.getHour();//时
        System.out.println("hour:" + hour);// hour:21

        int minute = nowTime.getMinute();//分
        System.out.println("minute:" + minute);// minute:57

        int second = nowTime.getSecond();//秒
        System.out.println("second:" + second);// second:50

        int nano = nowTime.getNano();//纳秒
        System.out.println("nano:" + nano);// nano:714000000

        System.out.println("-----");
        System.out.println(LocalTime.of(8, 20));//时分
        System.out.println(LocalTime.of(8, 20, 30));//时分秒
        System.out.println(LocalTime.of(8, 20, 30, 150));//时分秒纳秒
        LocalTime mTime = LocalTime.of(8, 20, 30, 150);

        System.out.println("---------------");
        System.out.println(LocalDateTime.of(1991, 11, 11, 8, 20));
        System.out.println(LocalDateTime.of(1991, Month.NOVEMBER, 11, 8, 20));
        System.out.println(LocalDateTime.of(1991, 11, 11, 8, 20, 30));
        System.out.println(LocalDateTime.of(1991, Month.NOVEMBER, 11, 8, 20, 30));
        System.out.println(LocalDateTime.of(1991, 11, 11, 8, 20, 30, 150));
        System.out.println(LocalDateTime.of(1991, Month.NOVEMBER, 11, 8, 20, 30, 150));
    }
}

package com.gch.d4_jdk8_time;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;

public class Demo03LocalDateTime {
    public static void main(String[] args) {
        // 日期 时间
        LocalDateTime nowDateTime = LocalDateTime.now();
        System.out.println("今天是:" + nowDateTime);// 今天是:2023-05-20T22:01:53.902
        System.out.println(nowDateTime.getYear());//年 2023
        System.out.println(nowDateTime.getMonthValue());//月 5
        System.out.println(nowDateTime.getDayOfMonth());//日 20
        System.out.println(nowDateTime.getHour());//时 22
        System.out.println(nowDateTime.getMinute());//分 1
        System.out.println(nowDateTime.getSecond());//秒 53
        System.out.println(nowDateTime.getNano());//纳秒 902000000
        //日：当年的第几天
        System.out.println("dayOfYear:" + nowDateTime.getDayOfYear());// dayOfYear:140
        //星期
        System.out.println(nowDateTime.getDayOfWeek());// SATURDAY
        System.out.println(nowDateTime.getDayOfWeek().getValue());// 6
        //月份
        System.out.println(nowDateTime.getMonth());// MAY
        System.out.println(nowDateTime.getMonth().getValue());// 5


        LocalDate ld = nowDateTime.toLocalDate();
        System.out.println(ld); // 2023-05-20

        LocalTime lt = nowDateTime.toLocalTime();
        System.out.println(lt.getHour()); // 22
        System.out.println(lt.getMinute()); // 1
        System.out.println(lt.getSecond()); // 53
    }
}

package com.gch.d4_jdk8_time;

import java.time.LocalDate;
import java.time.LocalTime;
import java.time.MonthDay;

public class Demo04UpdateTime {
    public static void main(String[] args) {
        LocalTime nowTime = LocalTime.now();
        System.out.println(nowTime);//当前时间
        System.out.println(nowTime.minusHours(1));//一小时前
        System.out.println(nowTime.minusMinutes(1));//一分钟前
        System.out.println(nowTime.minusSeconds(1));//一秒前
        System.out.println(nowTime.minusNanos(1));//一纳秒前

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

        System.out.println(nowTime.plusHours(1));//一小时后
        System.out.println(nowTime.plusMinutes(1));//一分钟后
        System.out.println(nowTime.plusSeconds(1));//一秒后
        System.out.println(nowTime.plusNanos(1));//一纳秒后

        System.out.println("------------------");
        // 不可变对象，每次修改产生新对象！
        System.out.println(nowTime);

        System.out.println("---------------");
        LocalDate myDate = LocalDate.of(2018, 9, 5);
        LocalDate nowDate = LocalDate.now();

        System.out.println("今天是2018-09-06吗？ " + nowDate.equals(myDate));//今天是2018-09-06吗？ false
        System.out.println(myDate + "是否在" + nowDate + "之前？ " + myDate.isBefore(nowDate));//2018-09-05是否在2018-09-06之前？ true
        System.out.println(myDate + "是否在" + nowDate + "之后？ " + myDate.isAfter(nowDate));//2018-09-05是否在2018-09-06之后？ false

        System.out.println("---------------------------");
        // 判断今天是否是你的生日
        LocalDate birDate = LocalDate.of(1996, 8, 5);
        LocalDate nowDate1 = LocalDate.now();

        MonthDay birMd = MonthDay.of(birDate.getMonthValue(), birDate.getDayOfMonth());
        MonthDay nowMd = MonthDay.from(nowDate1);

        System.out.println("今天是你的生日吗？ " + birMd.equals(nowMd));//今天是你的生日吗？ false
    }
}

package com.gch.d4_jdk8_time;

import java.time.LocalDate;
import java.time.LocalTime;
import java.time.MonthDay;

public class Demo04UpdateTime {
    public static void main(String[] args) {
        LocalTime nowTime = LocalTime.now();
        System.out.println(nowTime);//当前时间
        System.out.println(nowTime.minusHours(1));//一小时前
        System.out.println(nowTime.minusMinutes(1));//一分钟前
        System.out.println(nowTime.minusSeconds(1));//一秒前
        System.out.println(nowTime.minusNanos(1));//一纳秒前

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

        System.out.println(nowTime.plusHours(1));//一小时后
        System.out.println(nowTime.plusMinutes(1));//一分钟后
        System.out.println(nowTime.plusSeconds(1));//一秒后
        System.out.println(nowTime.plusNanos(1));//一纳秒后

        System.out.println("------------------");
        // 不可变对象，每次修改产生新对象！
        System.out.println(nowTime);

        System.out.println("---------------");
        LocalDate myDate = LocalDate.of(2018, 9, 5);
        LocalDate nowDate = LocalDate.now();

        System.out.println("今天是2018-09-06吗？ " + nowDate.equals(myDate));//今天是2018-09-06吗？ false
        System.out.println(myDate + "是否在" + nowDate + "之前？ " + myDate.isBefore(nowDate));//2018-09-05是否在2018-09-06之前？ true
        System.out.println(myDate + "是否在" + nowDate + "之后？ " + myDate.isAfter(nowDate));//2018-09-05是否在2018-09-06之后？ false

        System.out.println("---------------------------");
        // 判断今天是否是你的生日
        LocalDate birDate = LocalDate.of(1996, 8, 5);
        LocalDate nowDate1 = LocalDate.now();

        // 获取月日
        MonthDay birMd = MonthDay.of(birDate.getMonthValue(), birDate.getDayOfMonth());
        MonthDay nowMd = MonthDay.from(nowDate1);

        System.out.println("今天是你的生日吗？ " + birMd.equals(nowMd));//今天是你的生日吗？ false
    }
}

五. Instant

时间戳指的就是某一个时刻，某一个时刻就是年月日时分秒。

package com.gch.d4_jdk8_time;

import java.text.SimpleDateFormat;
import java.time.Instant;
import java.time.ZoneId;
import java.util.Date;

public class Demo05Instant {
    public static void main(String[] args) {
        // 1.得到一个Instant时间戳对象
        // 拿的是世界标准时间,全球统一的时间
        Instant instant1  = Instant.now(); // 我们的时间与世界标准时间差了八个小时
        System.out.println(instant1); // 2023-05-20T14:23:07.690Z

        // 2.系统此刻的时间戳怎么办?
        Instant instant2 = Instant.now(); // 2023-05-20T22:27:13.560+08:00[Asia/Shanghai]
        System.out.println(instant2.atZone(ZoneId.systemDefault()));

        // 3.如何去返回Date对象
        Date date = Date.from(instant2);
        System.out.println(date); // Sat May 20 22:30:26 CST 2023 // 2023年-05月-20日  22:31:32 星期六 下午
        System.out.println(new SimpleDateFormat("yyyy年-MM月-dd日  HH:mm:ss EEE a").format(date));
    }
}

六. DateTimeFormatter[日期时间格式化]

package com.gch.d4_jdk8_time;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
public class Demo06DateTimeFormat {
    public static void main(String[] args) {
        // 本地此刻  日期时间 对象
        LocalDateTime ldt = LocalDateTime.now();
        System.out.println(ldt); // 2023-05-20T22:39:35.190

        // 解析/格式化器
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss EEE a");
        // 正向格式化
        System.out.println(dtf.format(ldt)); // 2023-05-20 22:39:35 星期六 下午
        // 逆向格式化
        System.out.println(ldt.format(dtf)); // 2023-05-20 22:39:35 星期六 下午

        // 解析字符串时间
        DateTimeFormatter dtf1 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        // 解析当前字符串时间成为本地日期时间对象
        LocalDateTime ldt1 = LocalDateTime.parse("2019-11-11 11:11:11" ,  dtf1);
        System.out.println(ldt1); // 2019-11-11T11:11:11
        System.out.println(ldt1.getDayOfYear()); // 315
    }
}

七. Duration/Period

package com.gch.d4_jdk8_time;

import java.time.LocalDate;
import java.time.Period;

public class Demo07Period {
    public static void main(String[] args) {
        // 当前本地 年月日
        LocalDate today = LocalDate.now();
        System.out.println(today); // 2023-05-20

        // 生日的 年月日
        LocalDate birthDate = LocalDate.of(1998, 10, 13);
        System.out.println(birthDate); // 1998-10-13

        Period period = Period.between(birthDate, today);//第二个参数减第一个参数

        System.out.println(period.getYears()); // 24
        System.out.println(period.getMonths()); // 7
        System.out.println(period.getDays()); // 7
    }
}

package com.gch.d4_jdk8_time;

import java.time.Duration;
import java.time.LocalDateTime;

public class Demo08Duration {
    public static void main(String[] args) {
        // 本地日期时间对象。
        LocalDateTime today = LocalDateTime.now();
        System.out.println(today); // 2023-05-20T22:48:53.675

        // 出生的日期时间对象
        LocalDateTime birthDate = LocalDateTime.of(2021,8
                ,06,01,00,00);

        System.out.println(birthDate); // 2021-08-06T01:00

        Duration duration = Duration.between(today , birthDate);//第二个参数减第一个参数

        System.out.println(duration.toDays());//两个时间差的天数 // -652
        System.out.println(duration.toHours());//两个时间差的小时数 // -15669
        System.out.println(duration.toMinutes());//两个时间差的分钟数 // -940188
        System.out.println(duration.toMillis());//两个时间差的毫秒数 // -56411333675
        System.out.println(duration.toNanos());//两个时间差的纳秒数
    }
}

八. ChronoUnit

package com.itheima.d4_jdk8_time;

import java.time.LocalDateTime;
import java.time.temporal.ChronoUnit;

public class Demo09ChronoUnit {
    public static void main(String[] args) {
        // 本地日期时间对象：此刻的
        LocalDateTime today = LocalDateTime.now();
        System.out.println(today);

        // 生日时间
        LocalDateTime birthDate = LocalDateTime.of(1990,10,1,
                10,50,59);
        System.out.println(birthDate);

        System.out.println("相差的年数：" + ChronoUnit.YEARS.between(birthDate, today));
        System.out.println("相差的月数：" + ChronoUnit.MONTHS.between(birthDate, today));
        System.out.println("相差的周数：" + ChronoUnit.WEEKS.between(birthDate, today));
        System.out.println("相差的天数：" + ChronoUnit.DAYS.between(birthDate, today));
        System.out.println("相差的时数：" + ChronoUnit.HOURS.between(birthDate, today));
        System.out.println("相差的分数：" + ChronoUnit.MINUTES.between(birthDate, today));
        System.out.println("相差的秒数：" + ChronoUnit.SECONDS.between(birthDate, today));
        System.out.println("相差的毫秒数：" + ChronoUnit.MILLIS.between(birthDate, today));
        System.out.println("相差的微秒数：" + ChronoUnit.MICROS.between(birthDate, today));
        System.out.println("相差的纳秒数：" + ChronoUnit.NANOS.between(birthDate, today));
        System.out.println("相差的半天数：" + ChronoUnit.HALF_DAYS.between(birthDate, today));
        System.out.println("相差的十年数：" + ChronoUnit.DECADES.between(birthDate, today));
        System.out.println("相差的世纪（百年）数：" + ChronoUnit.CENTURIES.between(birthDate, today));
        System.out.println("相差的千年数：" + ChronoUnit.MILLENNIA.between(birthDate, today));
        System.out.println("相差的纪元数：" + ChronoUnit.ERAS.between(birthDate, today));
    }
}

九. 包装类

包装类就是8种基本数据类型对应的对象，就是把基本数据类型变成了一个对象。
包装类是引用数据类型，包装类的本质就是在堆内存中创建了一个对象，对象当中记录对应的数据值。而基本数据类型在变量中记录的是真实的数据值。
获取包装类对象，不需要调方法，直接赋值即可。
集合和泛型不支持基本数据类型，只支持引用数据类型。
包装类（位于java.lang包中）
在Java中，每一次new都是创建了一个新的对象

Java是强类型语言：每种数据在Java中都有各自的数据类型，在计算的时候，如果不是同一种数据类型，是无法直接计算的。

package com.gch.d5_integer;

/**
   目标明白包装类的概念,并使用
 */
public class Test {
    public static void main(String[] args) {
        int a = 10;
        Integer a1 = 11; // 引用类型,认为a1是对象变量
        System.out.println(a);
        System.out.println(a1);

        Integer a2 = a; // 自动装箱

        Integer it = 100;
        int it1 = it; // 自动拆箱
        System.out.println(it1);

//        int age = null; 报错了
        // Integer容错率更高
        Integer age1 = null;
        Integer age2 = 0;

        System.out.println("----------------------");
        // 1.包装类可以把基本类型的数据转换成字符串形式(没啥用)
        Integer i3 = 23;
        String rs = i3.toString();
        System.out.println(rs + 1); // 231

        // 包装类也可以直接+字符串得到字符串类型
        String rs2 = i3 + "";
        System.out.println(rs2 + 1); // 231

        System.out.println("----------------");
        String number = "23";
        // 转换成整数
//        int age = Integer.parseInt(number);
        int age = Integer.valueOf(number);
        System.out.println(age + 1); // 24

        String number1 = "99.9";
        // 转换成小数
//        double score = Double.parseDouble(number);
        double score = Double.valueOf(number1);
        System.out.println(score + 0.1); // 100
    }
}

Integer.valueOf(int i),如果i的值在-128到127之间,它会提前创建好Integer的对象,并且放到一个数组当中，用Integer.valueOf方法去获取对象的时候,它会判断你这个数据是不是在-128到127之间,如果说在,它不会创建新的对象,而是从数组当中获取已经创建好的对象给你返回,如果说不在-128到127之间,它才会new新的对象

   底层原理:

   因为在实际开发中,-128~127之间的数据,用的比较多
   如果每次使用都是new对象,那么太浪费内存了,所以提前把这个范围之内的每一个数据都创建好对象
   如果要用到了不会创建新的,而是返回已经创建好的对象。
   == 号是比较两个对象的地址值是否相同

package com.gch.d5_integer;

public class Test2 {
    public static void main(String[] args) {
        // 这两种方式获取对象的区别(掌握)
        // i的值都是127,不会创建新对象,而是获取已有对象
        Integer i6 = Integer.valueOf(127);
        Integer i7 = Integer.valueOf(127);
        System.out.println(i6 == i7); // true

        Integer i8 = Integer.valueOf(128);
        Integer i9 = Integer.valueOf(128);
        System.out.println(i8 == i9); // false

        // 因为看到了new关键字,在Java中,每一次new都是创建了一个新的对象
        // 所以下面的两个对象都是new出来,地址值不一样
        Integer i10 = new Integer(127);
        Integer i11 = new Integer(127);
        System.out.println(i10 == i11); // false

        Integer i12 = new Integer(128);
        Integer i13 = new Integer(128);
        System.out.println(i12 == i13); // false
    }
}

在JDK5的时候提出了一个机制:自动装箱和自动拆箱
自动装箱:把基本数据类型会自动地变成其对应的包装类
自动拆箱:把包装类自动地变成其对应的基本数据类型

在JDK5以后,int和Integer可以看作是同一个东西,因为在内部可以自动转化。

package com.gch.d5_integer;

public class Test3 {
    public static void main(String[] args) {
//        Integer i1 = 127;
//        Integer i2 = 127;
//        System.out.println(i1 == i2); // true

        // 在底层,此时还会去自动调用静态方法valueOf得到一个Integer对象,只不过这个动作不需要我们自己去操作了
        // 自动装箱的操作
        Integer i1= 10;

        Integer i2 = new Integer(10);
        // 自动拆箱的动作
        int i = i2;
    }
}

package com.gch.d5_integer;

public class Test4 {
    public static void main(String[] args) {
        Integer i1 = 10;
        Integer i2 = 10;
        // 引用数据类型不能直接计算,要先拆箱相加后再装箱赋值给i3
        Integer i3 = i1 + i2;
    }
}

public static String toBinaryString(int i) 得到二进制
public static String toOctalString(int i) 得到八进制
public static String toHexString(int i) 得到十六进制
public static int parseInt(String s) 将字符串类型的整数转成int类型的整数
为什么返回值类型为String,因为八进制有可能是01101101
int类型最多可以取到21亿,也就是最多只能有10位

package com.gch.d5_integer;

public class Test5 {
    public static void main(String[] args) {
        // 1.把整数转成二进制,十六进制
        String str1 = Integer.toBinaryString(100);
        System.out.println(str1); // 1100100

        // 2.把整数转成八进制
        String str2 = Integer.toOctalString(100);
        System.out.println(str2); // 144

        // 3.把整数转成十六进制
        String str3 = Integer.toHexString(100);
        System.out.println(str3); // 64

        // 4.将字符串类型的整数转成int类型的整数
        // 因为Java是强类型语言:每种数据在Java中都有各自的数据类型
        // 在计算的时候,如果不是同一种数据类型,是无法直接计算的
        int i = Integer.parseInt("123");
        System.out.println(i); // 123
        System.out.println(i + 1); // 124

        boolean b = Boolean.valueOf("true");
        System.out.println(b); // true
    }
}

package com.gch.d5_integer;

import java.util.Scanner;

public class Test6 {
    public static void main(String[] args) {
        // 键盘录入
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串:");
       /* String str = sc.next();
        System.out.println(str);*/
        // 弊端:
        // 当我们在使用next,nextInt,nextDouble在接收数据的时候,遇到空格,回车,制表符的时候就停止了
        // 键盘录入的是123 123 那么此时只能接收空格前面的数据
        // 我想要的是接收一整行数据
        // 约定:
        // 以后我们如果想要键盘录入,不管什么类型,统一使用nextLine
        // 特点:遇到回车才停止
        String line = sc.nextLine();
        System.out.println(line);
    }
}

Surpass余sheng军

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
日期时间类常见API以及包装类

Integer.valueOf(int i),如果i的值在-128到127之间,它会提前创建好Integer的对象,并且放到一个数组当中，用Integer.valueOf方法去获取对象的时候,它会判断你这个数据是不是在-128到127之间,如果说在,它不会创建新的对象,而是从数组当中获取已经创建好的对象给你返回,如果说不在-128到127之间,它才会new新的对象。包装类是引用数据类型，包装类的本质就是在堆内存中创建了一个对象，对象当中记录对应的数据值。如果要用到了不会创建新的,而是返回已经创建好的对象。
复制链接

扫一扫