Math.abs(); //绝对值 JDK15之后有异常处理 Math.absExact();
Math.ceil(); //向上取整
Math.floor(); //向下取整
Math.round(); //四舍五入
Math.max(); //取最大值
Math.min(); //取最小值
Math.pow(a,b); //a^b
Math.sqrt(); //平方根
Math.random(); //随机数 范围[0-1)</code></pre></details>

System.exit();//终止虚拟机 status：0 正常结束/ 1 异常结束 底层调用了Runtime类的exit()方法
System.currentTimeMillis();//到时间原点所过去的时间(ms),可用于判断程序运行时间
/*
数据拷贝 
参数(数据源，数据源开始拷贝索引，目的地，目的地索引，拷贝个数)
细节：
    1.拷贝基本数据类型，需要保证数据类型一致 
    2.需要考虑数组长度
    3.引用数据类型，子类可以赋值给父类
*/
System.arraycopy(); 

public class Runtime {
    private static final Runtime currentRuntime = new Runtime();

    private static Version version;

    /**
     * Returns the runtime objectassociated with the currentJava application.
     * Mostof the methods of class {@code Runtime} are instance
     * methods and mustbe invoked with respectto the currentruntime object.
     *
     * @return  the {@code Runtime} objectassociated with the current
     *          Java application.
     */
    public static Runtime getRuntime() {
        return currentRuntime;
    }

    /** Don'tletanyone else instantiate this class */
    private Runtime() {}
}

//静态方法
Runtime.getRuntime();//获取当前系统运行环境的对象

//实例化方法
Runtime.getRuntime().exit(）//停止虚拟机 status：0 正常结束/ 1 异常结束
Runtime.getRuntime().availableProcessors();//获取CPU线程数
Runtime.getRuntime().maxMemory();//JVM从系统中获得的总内存的大小
Runtime.getRuntime().totalMemory();//JVM已从系统中获得的内存大小
Runtime.getRuntime().freeMemory();//JVM中剩余内存
Runtime.getRuntime().exec("");//运行cmd命令

/*
返回对象的地址，字符串表示形式：包+类@地址
System.out.println(obj);效果等同于toString();
默认情况下，返回地址值没有太大作用，一般会在子类中重写，用来拼接属性并打印
*/
public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

/*
类Object下的该方法是判断对象的地址值是否相等
而子类通常会重写该方法，用来比较对象内部的属性值是否相等：如String包下的equals()方法
*/
public boolean equals(Objectobj) {
return (this == obj);
}

/*
对象克隆：完全拷贝属性值，但该方法受保护，需要重写。
Cloneable接口：如果一个接口内没有抽象方法，说明该接口是标志性接口，Cloneable一旦被发现，
那么当前类就可以被克隆。
方法在底层会帮我们创建一个对象，并把源对象中的数据拷贝过去。
例如，学生类实现了Cloneable接口，该类就可以被克隆。
public class Clone {
public static void main(String[] args) throws CloneNotSupportedException {
Studentstu1 = new Student(11,"zhangsan",120,101);
Studentstu2 =(Student) stu1.clone(); //强转
System.out.println(stu1);
System.out.println(stu2);
}
}
步骤：
1.重写Object中的Clone()方法
2.让javabean类实现Cloneable接口
3.创建原对象，然后调用Clone()方法

注意：该方法是浅克隆
*/
protected native Objectclone() throws CloneNotSupportedException;

/*
原理：
        当打印一个对象时，底层会调用对象的toString方法，将对象变为字符串，打印到控制台
        System：类名
        out：静态变量
        System.out：获取打印对象
        println();方法
*/

//println源码
public void println(Objectx) {
String s = String.valueOf(x); //先通过String.valueOf()获取对象；
synchronized (this) {
print(s);
newLine();
}
}

//valueOf源码
public static String valueOf(Objectobj) {
return (obj == null) ? "null" : obj.toString(); //底层仍然是obj.toString()方法
}

/*
源码
String 类中重写了 equals() 方法用于比较两个字符串的内容是否相等。
先判断两个串的地址是否相同，相同则返回true，不同则进行比较内容
*/
public boolean equals(ObjectanObject) {
    if (this == anObject) {
        return true;
    }
    if (anObjectinstanceof String) {
        String aString = (String)anObject;
        if (coder() == aString.coder()) {
            return isLatin1() ? StringLatin1.equals(value, aString.value)
                    : StringUTF16.equals(value, aString.value);
        }
    }
    return false;
}

/*
代码举例
*/
String s1 = "Hello";              // String 直接创建
String s2 = "Hello";              // String 直接创建
String s3 = s1;                   // 相同引用
String s4 = new String("Hello");  // String 对象创建
String s5 = new String("Hello");  // String 对象创建

s1 == s1;         // true, 相同引用
s1 == s2;         // true, s1 和 s2 都在公共池中，引用相同
s1 == s3;         // true, s3 与 s1 引用相同
s1 == s4;         // false, 不同引用地址
s4 == s5;         // false, 堆中不同引用地址

s1.equals(s3);    // true, 相同内容
s1.equals(s4);    // true, 相同内容
s4.equals(s5);    // true, 相同内容  

public void gsonCopy() {

    Address address = new Address("杭州", "中国");
    User user = new User("大山", address);

    // 使用Gson序列化进行深拷贝
    Gson gson = new Gson();
    User copyUser = gson.fromJson(gson.toJson(user), User.class);
    /*
    也可以写作
    String s = gson.toJson(user);
    User copyUser = gson.fromJson(s, User.class);
    */
    // 修改源对象的值
    user.getAddress().setCity("深圳");

    // 检查两个对象的值不同
    assertNotSame(user.getAddress().getCity(), copyUser.getAddress().getCity());
}

/*
先做地址判等、非空判断、然后再调用Object的实例化equals()方法比较两个对象的地址值是否相等
细节：
    如果重写了Object的实例化equals()方法，则会比较属性值，否则会做地址判等
*/
public static boolean equals(Objecta, Objectb) {
        return (a == b) || (a != null && a.equals(b));
    }

//判断是否为空
public static boolean isNull(Objectobj) {
return obj == null;
}

//判断是否不空
public static boolean nonNull(Objectobj) {
return obj != null;
}

//构造一个随机生成的BigInteger，均匀分布在[0,2^numBits - 1]的范围内。
BigInteger(intnumBits, Random rnd)	

//将BigInteger的十进制字符串表示形式转换为BigInteger。
BigInteger(String val)

//将指定基数中BigInteger的String表示形式转换为BigInteger。
BigInteger(String val, intradix)

静态方法	  
//返回一个BigInteger，其值等于指定的 long 
//只能在long的范围内
/*
在内部对-16~16进行了优化，先创建好了-16~16的BigInteger对象，多次获取不会重新创建
对象一旦创建，内部的数据不会改变，不会改变参与计算的BigInteger对象中的值，而是产生一个
新的BigInteger对象记录新值。
*/
static BigInteger	valueOf(long val)	

//将 double转换为 BigDecimal ，它是 double的二进制浮点值的精确十进制表示。
//可能不精确，不建议使用
BigDecimal(double val) 

/*将 BigDecimal的字符串表示 BigDecimal转换为 BigDecimal 。
对于float和double NaN和±Infinity之外的值，
此构造函数与Float.toString(float)和Double.toString(double)返回的值兼容。
这通常是将float或double转换为BigDecimal的首选方式，
因为它不会遭受BigDecimal(double)构造函数的不可预测性。
*/
BigDecimal(String val)   

/*
 转换一个 double成 BigDecimal ，使用 double通过所提供的规范的字符串表示
 Double.toString(double)方法。  
*/
static BigDecimal valueOf(double val)

public BigDecimal add(BigDecimal val) //加法

public BigDecimal subtract(BigDecimal val) //减法

public BigDecimal multiply(BigDecimal val) //乘法

public BigDecimal divide(BigDecimal val) //除法 除不尽时候不可用

public BigDecimal divide(BigDecimal val,精确几位，舍入模式) //除法

手机号验证的正则表达式

//分成三部分理解：
//第一部分：手机号只能是1开头
//第二部分：手机号的第二位是3-9之间的任意数字
//第三部分：手机号第三位到最后一位的9位数字可以是任意数字
String regex = "1[3-9]\\d{9}";
System.out.printlf("15148877290".matches(regex));

//座机号分成三部分
//区号:一定是以0开头，区号从第二位开始可以是任意数字，可以出现2-3次
//-：可以出现0次或者1次
//号码:第一位不能0开头，其余可以是任意数字，号码总长度5-10位
String regex = "0\\d{2,3}-?[1-9]\\d{4,9}";
System.out.println("0478-1234567".matches(regex));

// 分为三部分：
// 第一部分@左：数字、字母、下划线，至少出现一次
// 第二部分@:只能出现一次
// 第三部分：分为三小部分
//		 .左：长度为2-6，不能出现下划线，可以是数字、字母
// 		 .：出现一次
// 		 .右：大写字母、小写字母均可，只能出现2-3次
// 		  将.和.右看为一个整体，该整体可以出现1-2次
// 如：dmk123@pci.com.cn
String regex = "\\w+@[\\w&&[^_]]{2,6}(\\.[a-zA-Z]{2,3}){1,2}";  

//大小写字母、数字、下划线，一共4-16位
String regex = "\\w{4,16}";

//前17位任意数字，最后一位可以是X、x
String regex = "[1-9]\\d{16}[\\dXx]";
//忽略大小写  (?i)可以将后面的字母忽略大小写
String regex2 = "[1-9]\\d{16}(\\d|(?i)x);

//爬取的目标串
String str = Java自从95年问世以来，经历了很多版本，目前企业中用的最多是Java8和Java11，+
因为这两个是长期支持版本，下一个长期支持版本是Java17，相信在不久的未来Java17也会逐渐登上历史的舞台;

/*
//Pattern：表示正则表达式
//Matcher：文本匹配器，按照正则表达式的规则去读取字符串，从头开始读取。在大串中匹配合适的子串

//获取正则表达式对象
Pattern p = new Pattern.compile("Java\\d{0,2}");

// 获取文本匹配器对象
// m：文本匹配器对象
// str：大串
// p：规则
// m要在str中寻找符合p规则的小串
Matcher m = p.matcher(str);

// 拿着文本匹配器从头开始读取，寻找是否有满足条件的子串
// 如果没有，方法返回false
// 如果有，返回true。在底层记录子串的起始索引和结束索引+1
boolean b = m.find();

// 方法底层会根据find方法记录的索引进行字符串的截取
// subString(起始索引，结束索引)；包头不包尾，比如截取(0,4)，截取的为0,1,2,3
String s1 = m.group();
system.out.println(s1);
*/

//1.获取正则表达式对象
Pattern p = Pattern.compile("Java\\d{0,2}");

//2.获取文本匹配器对象
// 拿着m去读取str，找到符合p规则的子串
Matcher m = p.matcher(str);

//3.利用循环获取
while(m.find()){
String s = m.group();
System.out.println(s);n
}

//?理解为前面的数据Java
// =表示Java后面要跟随的数据
// 但是在获取的时候，只获取前半部分
String regex = "Java(?=8|11|17);

//判断字符串是否满足正则表达式的规则
public String[] matches(String regex);

//按照正则表达式的规则进行替换
public String replaceAll(String regex,String newStr);

//按照正则表达式的规则切割字符串
public String[] split(String regex);

//需求一：判断一个字符串的开始字符和结束字符是否一致
String regex = "(.).+\\1";
System.out.println("a13a".matches(regex));

//需求二:判断一个字符串的开始部分和结束部分是否一致，可以是多个字符
String regex = "(.+).+\\1";
System.out.println("abc13abc".matches(regex));

//需求三：判断一个字符串的开始部分和结束部分是否一致，开始部分内的每个字符都必须一致
String regex = "((.)\\2*).+\\1"; \\将首字母(.)看作一组，反复\\2出现*次
System.out.println("aaa13aaa".matches(regex));

//需求三：将字符串中的重复内容去重
String regex = (wyxxxxxbbbbbbbccccccc);
//将任意字符看为第一组，且重复出现至少一次，$1在正则表达式之外使用第一个分组
String result= str.replaceAll("(.)\\1+";,"$1");
System.out.println("wyxbc";);

利用空参构造创建的对象，表示系统当前时间

利用有参构造创建的对象，表示指定时间

Date类的构造方法与实例化方法  

public Date(){} //无参构造	表示当前时间
public Date(long date){}//有参构造，指定时间

public void setTime(long time) //设置、修改时间 (ms)
public long getTime() //获取时间对象的毫秒值

//需求一：打印时间原点一年之后时间
//1.创建一个时间对象，表示时间原点
Date d1 = new Date(0L);

// 2.获取d1时间的毫秒值
long time = d1.getTime();

//3.在这个基础上加一年的毫秒值即可
time = time + 1000L * 60 * 60 * 24 * 365;

//把计算之后的毫秒值，再设置回d1当中
d1.setTime(time);

//打印d1
System.out.printlf(d1);

// 需求二：定义任意两个Date对象，比较一下时间前后
// 创建随机数对象
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();

// 再进行时间比较，比较time1 和 time2值的大小

public SimpleDateFormat() 	//使用默认格式构造
public SimpleDateFormat(String pattern) //使用指定格式构造

public final String format(Date date) //格式化(日期对象->字符串)
public Date parse(String source) //解析（字符串->日期对象）

// 1.利用空参构造创建SimpleDateFormat对象，默认格式
SimpleDateFormatsdf1 = new SimpleDateFormat();
Data d1 = new Date();
String str1 = sdf1.format(d1);
System.out,println(str1);

//2.利用带参构造创建SimpleDateFormat对象，指定格式
SimpleDateFormatsdf2 = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss EE");
Date d2 = new Date();
Stirng str2 = sdf2.format(d2);
System.out.println(str2);

String str = "2024-6-1 10:33:19";

// 创建DateSimpleFormat对象，格式与字符串中的格式必须一致
DateSimpleFormatdsf = new DateSimpleFormat("yyyy-MM-dd HH:mm:ss");
// 解析
Date date = sdf.parse(data);
System.out,println(date);

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

// 获取时间
// 使用默认时区和语言环境获得一个日历
    Calendar cal = Calendar.getInstance();
    // 赋值时年月日时分秒常用的6个值，注意月份下标从0开始，所以取月份要+1
    System.out.println("年:" + cal.get(Calendar.YEAR));
    System.out.println("月:" + (cal.get(Calendar.MONTH) + 1));       
    System.out.println("日:" + cal.get(Calendar.DAY_OF_MONTH));
    System.out.println("时:" + cal.get(Calendar.HOUR_OF_DAY));
    System.out.println("分:" + cal.get(Calendar.MINUTE));
    System.out.println("秒:" + cal.get(Calendar.SECOND));


// 设置时间
// 月份的下标从 0 开始，设置时同样需要注意，比如我们设置为 2 月 15 日除夕当晚的倒计时的最后一秒： 2018-02-15 23:59:59
//可以这样：
    Calendar cal = Calendar.getInstance();
    // 如果想设置为某个日期，可以一次设置年月日时分秒，由于月份下标从0开始赋值月份要-1
    // cal.set(year, month, date, hourOfDay, minute, second);
    cal.set(2018, 1, 15, 23, 59, 59);

//或者也可以单个字段一一设置：

    // 或者6个字段分别进行设置，由于月份下标从0开始赋值月份要-1
    cal.set(Calendar.YEAR, 2018);
    cal.set(Calendar.MONTH, Calendar.FEBRUARY);
    cal.set(Calendar.DAY_OF_MONTH, 15);
    cal.set(Calendar.HOUR_OF_DAY, 23);
    cal.set(Calendar.MINUTE, 59);
    cal.set(Calendar.SECOND, 59);
    System.out.println(cal.getTime());

Calendar cal = Calendar.getInstance();
System.out.println(cal.getTime());
cal.set(2018, 1, 15, 23, 59, 59);
cal.add(Calendar.SECOND, 1);
System.out.println(cal.getTime());

Thu Feb 15 23:59:59 CST 2018
Fri Feb 16 00:00:00 CST 2018

/*
        static Set<string> getAvailableZoneIds() 获取Java中支持的所有时区
        static ZoneId systemDefault() 获取系统默认时区
        static Zoneld of(string zoneld) 获取一个指定时区
        */

//1.获取所有的时区名称
Set<String> zoneIds = ZoneId.getAvailableZoneIds();
System.out.println(zoneIds.size());//600
System.out.println(zoneIds);// Asia/Shanghai

//2.获取当前系统的默认时区
ZoneId zoneId = ZoneId.systemDefault();
System.out.println(zoneId);//Asia/Shanghai

//3.获取指定的时区
ZoneId zoneId1 = ZoneId.of("Asia/Pontianak");
System.out.println(zoneId1);//Asia/Pontianak

/*
            static Instantnow() 获取当前时间的Instant对象(标准时间)
            static InstantofXxxx(long epochMilli) 根据(秒/毫秒/纳秒)获取Instant对象
            ZonedDateTime atZone(ZoneIdzone) 指定时区
            boolean isxxx(InstantotherInstant) 判断系列的方法
            InstantminusXxx(long millisToSubtract) 减少时间系列的方法
            InstantplusXxx(long millisToSubtract) 增加时间系列的方法
        */
//1.获取当前时间的Instant对象(标准时间)
Instantnow = Instant.now();
System.out.println(now);

//2.根据(秒/毫秒/纳秒)获取Instant对象
Instantinstant1 = Instant.ofEpochMilli(0L);
System.out.println(instant1);//1970-01-01T00:00:00z

Instantinstant2 = Instant.ofEpochSecond(1L);
System.out.println(instant2);//1970-01-01T00:00:01Z

Instantinstant3 = Instant.ofEpochSecond(1L, 1000000000L);
System.out.println(instant3);//1970-01-01T00:00:027

//3. 指定时区
ZonedDateTime time = Instant.now().atZone(ZoneId.of("Asia/Shanghai"));
System.out.println(time);


//4.isXxx 判断
Instantinstant4=Instant.ofEpochMilli(0L);
Instantinstant5 =Instant.ofEpochMilli(1000L);

//5.用于时间的判断
//isBefore:判断调用者代表的时间是否在参数表示时间的前面
boolean result1=instant4.isBefore(instant5);
System.out.println(result1);//true

//isAfter:判断调用者代表的时间是否在参数表示时间的后面
boolean result2 = instant4.isAfter(instant5);
System.out.println(result2);//false

//6.InstantminusXxx(long millisToSubtract) 减少时间系列的方法
Instantinstant6 =Instant.ofEpochMilli(3000L);
System.out.println(instant6);//1970-01-01T00:00:03Z

Instantinstant7 =instant6.minusSeconds(1);
System.out.println(instant7);//1970-01-01T00:00:02Z

/*
            static ZonedDateTime now() 获取当前时间的ZonedDateTime对象
            static ZonedDateTime ofXxxx(。。。) 获取指定时间的ZonedDateTime对象
            ZonedDateTime withXxx(时间) 修改时间系列的方法
            ZonedDateTime minusXxx(时间) 减少时间系列的方法
            ZonedDateTime plusXxx(时间) 增加时间系列的方法
         */
//1.获取当前时间对象(带时区)
ZonedDateTime now = ZonedDateTime.now();
System.out.println(now);

//2.获取指定的时间对象(带时区)1/年月日时分秒纳秒方式指定
ZonedDateTime time1 = ZonedDateTime.of(2023, 10, 1,
                                       11, 12, 12, 0, ZoneId.of("Asia/Shanghai"));
System.out.println(time1);

//通过Instant+ 时区的方式指定获取时间对象
Instantinstant= Instant.ofEpochMilli(0L);
ZoneId zoneId = ZoneId.of("Asia/Shanghai");
ZonedDateTime time2 = ZonedDateTime.ofInstant(instant, zoneId);
System.out.println(time2);


//3.withXxx 修改时间系列的方法
ZonedDateTime time3 = time2.withYear(2000);
System.out.println(time3);

//4. 减少时间
ZonedDateTime time4 = time3.minusYears(1);
System.out.println(time4);

//5.增加时间
ZonedDateTime time5 = time4.plusYears(1);
System.out.println(time5);

/*
            static DateTimeFormatter ofPattern(格式) 获取格式对象
            String format(时间对象) 按照指定方式格式化
        */
//获取时间对象
ZonedDateTime time = Instant.now().atZone(ZoneId.of("Asia/Shanghai"));

// 解析/格式化器
DateTimeFormatter dtf1=DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm;ss EE a");
// 格式化
System.out.println(dtf1.format(time));

//1.获取当前时间的日历对象(包含 年月日)
LocalDate nowDate = LocalDate.now();
//System.out.println("今天的日期:" + nowDate);
//2.获取指定的时间的日历对象
LocalDate ldDate = LocalDate.of(2023, 1, 1);
System.out.println("指定日期:" + ldDate);

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

//3.get系列方法获取日历中的每一个属性值//获取年
intyear = ldDate.getYear();
System.out.println("year: " + year);
//获取月//方式一:
Month m = ldDate.getMonth();
System.out.println(m);
System.out.println(m.getValue());

//方式二:
intmonth = ldDate.getMonthValue();
System.out.println("month: " + month);


//获取日
intday = ldDate.getDayOfMonth();
System.out.println("day:" + day);

//获取一年的第几天
intdayofYear = ldDate.getDayOfYear();
System.out.println("dayOfYear:" + dayofYear);

//获取星期
DayOfWeek dayOfWeek = ldDate.getDayOfWeek();
System.out.println(dayOfWeek);
System.out.println(dayOfWeek.getValue());

//is开头的方法表示判断
System.out.println(ldDate.isBefore(ldDate));
System.out.println(ldDate.isAfter(ldDate));

//with开头的方法表示修改，只能修改年月日
LocalDate withLocalDate = ldDate.withYear(2000);
System.out.println(withLocalDate);

//minus开头的方法表示减少，只能减少年月日
LocalDate minusLocalDate = ldDate.minusYears(1);
System.out.println(minusLocalDate);


//plus开头的方法表示增加，只能增加年月日
LocalDate plusLocalDate = ldDate.plusDays(1);
System.out.println(plusLocalDate);

//-------------
// 判断今天是否是你的生日
LocalDate birDate = LocalDate.of(2000, 1, 1);
LocalDate nowDate1 = LocalDate.now();

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

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

// 获取本地时间的日历对象。(包含 时分秒)
LocalTime nowTime = LocalTime.now();
System.out.println("今天的时间:" + nowTime);

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

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

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

intnano = nowTime.getNano();//纳秒
System.out.println("nano:" + nano);
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);

//is系列的方法
System.out.println(nowTime.isBefore(mTime));
System.out.println(nowTime.isAfter(mTime));

//with系列的方法，只能修改时、分、秒
System.out.println(nowTime.withHour(10));

//plus系列的方法，只能修改时、分、秒
System.out.println(nowTime.plusHours(10));

// 当前时间的的日历对象(包含年月日时分秒)
LocalDateTime nowDateTime = LocalDateTime.now();

System.out.println("今天是:" + nowDateTime);//今天是：
System.out.println(nowDateTime.getYear());//年
System.out.println(nowDateTime.getMonthValue());//月
System.out.println(nowDateTime.getDayOfMonth());//日
System.out.println(nowDateTime.getHour());//时
System.out.println(nowDateTime.getMinute());//分
System.out.println(nowDateTime.getSecond());//秒
System.out.println(nowDateTime.getNano());//纳秒
// 日:当年的第几天
System.out.println("dayofYear:" + nowDateTime.getDayOfYear());
//星期
System.out.println(nowDateTime.getDayOfWeek());
System.out.println(nowDateTime.getDayOfWeek().getValue());
//月份
System.out.println(nowDateTime.getMonth());
System.out.println(nowDateTime.getMonth().getValue());

LocalDate ld = nowDateTime.toLocalDate();
System.out.println(ld);

LocalTime lt= nowDateTime.toLocalTime();
System.out.println(lt.getHour());
System.out.println(lt.getMinute());
System.out.println(lt.getSecond());

// 本地日期时间对象。
LocalDateTime today = LocalDateTime.now();
System.out.println(today);

// 出生的日期时间对象
LocalDateTime birthDate = LocalDateTime.of(2000, 1, 1, 0, 0, 0);
System.out.println(birthDate);

Duration duration = Duration.between(birthDate, today);//第二个参数减第一个参数
System.out.println("相差的时间间隔对象:" + duration);

System.out.println("============================================");
System.out.println(duration.toDays());//两个时间差的天数
System.out.println(duration.toHours());//两个时间差的小时数
System.out.println(duration.toMinutes());//两个时间差的分钟数
System.out.println(duration.toMillis());//两个时间差的毫秒数
System.out.println(duration.toNanos());//两个时间差的纳秒数

// 当前本地 年月日
LocalDate today = LocalDate.now();
System.out.println(today);

// 生日的 年月日
LocalDate birthDate = LocalDate.of(2000, 1, 1);
System.out.println(birthDate);

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

System.out.println("相差的时间间隔对象:" + period);
System.out.println(period.getYears());
System.out.println(period.getMonths());
System.out.println(period.getDays());

System.out.println(period.toTotalMonths());

// 当前时间
LocalDateTime today = LocalDateTime.now();
System.out.println(today);
// 生日时间
LocalDateTime birthDate = LocalDateTime.of(2000, 1, 1,0, 0, 0);
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));

// //public Integer(intvalue)：根据 int值创建 Integer 对象(过时)
// Integer i1 = new Integer(100);
// System.out.println(i1);

// //public Integer(String s)：根据 String 值创建 Integer 对象(过时)
// Integer i2 = new Integer("100");
// //Integer i2 = new Integer("abc"); //NumberFormatException
// System.out.println(i2);
// System.out.println("--------");



//public static Integer valueOf(inti)：返回表示指定的 int值的 Integer 实例
Integer i3 = Integer.valueOf(100);
System.out.println(i3);

//public static Integer valueOf(String s)：返回保存指定String值的Integer对象 
Integer i4 = Integer.valueOf("100");
System.out.println(i4);

//因为在实际开发中，-128~127之间的数据，用的比较多。
//如果每次使用都是new对象，那么太浪费内存了
//所以，提前把这个范围之内的每一个数据都创建好对象
//如果要用到了不会创建新的，而是返回已经创建好的对象。
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);

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

/*当调用valueOf的方法是先会对传入的参数进行判断，然后根据判断情况返回相应的对象
public static Integer valueOf(inti) {
        //在此范围内返回一个对象
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)]; //cache为数组
        return new Integer(i);
    }

//Integer类型的数组
static final Integer[] cache;

/*
            public static string tobinarystring(inti) 得到二进制
            public static string tooctalstring(inti) 得到八进制
            public static string toHexstring(inti) 得到十六进制
            public static intparseInt(string s) 将字符串类型的整数转成int类型的整数
 */

//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中都有各自的数据类型
//在计算的时候，如果不是同一种数据类型，是无法直接计算的。
inti = Integer.parseInt("123");
System.out.println(i);
System.out.println(i + 1);//124
//细节1:
//在类型转换的时候，括号中的参数只能是数字不能是其他，否则代码会报错
//细节2:
//8种包装类当中，除了Character都有对应的parseXxx的方法，进行类型转换
String str = "true";
boolean b = Boolean.parseBoolean(str);
System.out.println(b);
// 除了Character类之外，其他所有包装类都具有parseXxx静态方法可以将字符串参数转换为对应的基本类型：

//  `public static byte parseByte(String s)`：将字符串参数转换为对应的byte基本类型。
//  `public static shortparseShort(String s)`：将字符串参数转换为对应的short基本类型。
//  **`public static intparseInt(String s)`：将字符串参数转换为对应的int基本类型。**
//  **`public static long parseLong(String s)`：将字符串参数转换为对应的long基本类型。**
//  `public static floatparseFloat(String s)`：将字符串参数转换为对应的float基本类型。
//  `public static double parseDouble(String s)`：将字符串参数转换为对应的double基本类型。
//  `public static boolean parseBoolean(String s)`：将字符串参数转换为对应的boolean基本类型。

// 在以前 包装类进行计算
Integer i1 = new Integer(1);
Integer i2 = new Integer(2);

// 步骤：
// 1.先将对象进行拆箱
// 2.相加
// 3.将结果再次装箱

intresult= i1.intValue() + i2.intValue();
Integer i3 = new Integer(result);
System.out.println(i3);

// 在JDK5的时候提出了一个机制，自动装箱和自动拆箱
Integer i = 4;//自动装 箱。相当于Integer i = Integer.valueOf(4);
i = i + 5;//等号右边：将i对象转成基本数值(自动拆箱) i.intValue() + 5;
//加法运算完成后，再次装箱，把基本数值转成对象。

Scanner sc = new Scanner(System.in);
String str = sc.next();
System.out.println(str);
/*
弊端：
当使用next、nextInt、nextLine接收数据的时候，遇到空格、制表符、回车都会停止
约定：使用nextLine来录入数据
再根据需要的数据类型进行数据转换
*/