Java 罕用类

记录一些 Java 学习应用, 常常应用类进行总结.. 这个文章感觉还是很有必要的 前面会常总结扩大 …

String 字符串相干的类

String Java.lang 包

Java 中字符串被称作为 String 类型对象来解决 String 类是 Java 设计人员事后提供一个十分有用的类 Java.lang 包中！

• String 是一个 final 类，代表不可变的字符序列
• 字符串是常量，用双引号引起来示意。它们的值：在创立之后不能更改
• String 对象的字符内容是存储在一个字符数组 value[]中的 👀
• 实现了 序列化 Comparable 比拟器 CharSequence 接口

String 对象的创立：

子面量定义形式; 
    String s = "Hello World";     就是咱们罕用的形式...     
    
String 代表不可变的字符序列, 简称不可变性:
    在不 new String("");             状况间接赋值雷同值 String 类型对象,== 比拟是雷同的;
    
     String a = "abc";     
     String b = "abc";
     boolean isok = (a==b);        后果为 true;(== 比对象比地址)    
起因：Java 首次通过字面量形式申明给一个字符串赋值时, 会将字符串值申明在: "Jvm 办法区中常量池里, 并把地址赋值给, 栈空间中的 String 对象上;"
    当又一个 String 对象以字面量的形式赋同样的值, 它会间接援用雷同的地址值;
    所以: "字面量赋值雷同的 String 对象值 == 比拟值雷同后果为: true" (其实就是地址雷同;
String 不可变性:
    当对字符串的值, 从新赋值 / 拼接时, 常量池中会呈现你新赋值的一个空间字符串, 须要从新指定常量池的地址值; 而不是在扭转原先空间的值;    

String s =  new String();
    new 创立一个空字符串, 相当于底层 new char[0];
    在堆空间创立出, 空间存储值, 并把地址复制给, 栈空间的对象援用;
    所以：String s = new String("s"); 
        String s1 = new String("s");
        boolean isok = (s==s1);         后果为 false
        对象指向的是堆空间的地址,new 一个就产生一个... 所以两个 new 对象的地址永远不会 true;
        但因为 String 值是寄存在 常量池中的... 所以其实真实情况是: "对象栈———指向 > 堆地址 ——指向 > 办法区"     

String 的内存解析：

首先咱们要晓得：Java 创建对象

• JVM 外面有两个用于存储对象的空间 堆 栈
  堆： 寄存所有 new 进去的对象
  栈： 寄存根本类型的变量数据和对象的援用 对象自身不寄存在栈中，而是寄存在：堆 或 常量池; 援用类型栈对象只指向堆的地址~
  所以： new a 和 new b 程序在堆空间开启了两个地址，a b 指向的 堆地址不同 a==b == 比拟地址返回 false

• 首先对于对象援用类型，程序每 new 一次的操作, 都会在 JVM 的堆空间中开拓一个内存空间 …

  ---

  字面量形式赋值：
  
  new String() 赋值：
  

  String 类的罕用办法();

  这里就不一一举例了，应用多了天然就会用了 …

int            .length();            // 返回字符串长度;
char[]        .toCharArray();        //String 与 char[]数组转换; 
                                //char[]数组转换成 String  String str = new String(char[]);
                                
byte[]        .getBytes();        //String 与 byte[]数组转换; byte 类型值是数值类型的哦; a 对应 97... 
                                留神中文: 分为一个 / 多个字节, 留神编码格局; .getBytes(); 应用编辑器默认编码格局, 能够通过.getBytes("utf-8"); 指定编码格局; 
                                一个中文 utf- 8 是 3 个字节; GBK 是 2 个字节;

boolean        .isEmpty();            // 判断字符串是否是否是空字符; 
                                str.length()==0; 空 true 则 false
                                
boolean        .startWith(str);    // 判断以后字符串是否以 str 结尾是 true 则 false 辨别大小写;
boolean        .endsWith(str);        // 判断以后字符串是否以 str 结尾是 true 则 false 辨别大小写;

boolean        .contains();        // 该办法判断字符串中是否有指定字符内容,
                                有 true 无则 false; 
                                eg: ABCD.conntains("ABC"); true; 
                                
int            .compareTo(String); // 比拟字符串大小; 可进行字符串排序;  
                                str.compareTo(str1); 一个给比拟外部值 正数 str 小, 负数 str 大 0str 一样大等于 str1;
                                
char        .charAt(int);        // 获取指定地位的字符; 
                                留神数组越界 "String 归根结底是一个 char[] 字符数组！"
                                
String        .replace("1","2");    // 替换将字符串 
                                指定地位 1 字符 / 字符串, 替换为 2 字符 / 字符串;
                                
boolean     .equals(String);    // 比拟字符串值是否统一 String 
                                "String 重写了 Object 类的 equals(Objetc o)办法;"
                                
String        .toLowerCase();        // 转换 字符串 中英文字母 为小写; 
                                返回字符串小写模式, 不影响堆 / 常量池
String         .toUpperCase();        // 转换 字符串 中英文字母 为大写; 
                                返回字符串大写模式, 不影响堆 / 常量池
String        .concat();            // 字符串 1 .concat(字符串 2); 
                                将 2 内容追加在 1 前面返回字符串; 也能够用 '+' 拼接但效率低下;    
                                                                        
String      .trim();            返回一个不含空格的字符串; 将字符串中所有空格勾销;
int            .indexof('');        从头开始搜寻  获取字符在字符串中的地位:
                                下标 0 开始 如果没有 该字符返回 -1;     // 如果参数是字符串以第一个字符为准
                                
int            .lastIndexof('');    从后搜寻第一个合乎指定字符的地位 0 开始没有返回 -1;    // 如果参数 是 字符串 以第一个 字符为准
String        .Substring(int);        // 提取从索引地位开始到前面所有的 字符串 返回;
String        .Substring(int1,int2);    // 提取范畴内字符串;
String[]    .spilt(String,int);        // 拆分:
                                    依据 String 字符为拆分 字符进行拆分 返回 拆分后字符串数组[] 如果不指定 String 则 按 每个单字符 返回 数组;
                                    int 用来限度返回数组中元素个数; "可选, 默认即不限度返回 String[] 数组！";
                                    还能够是 正则表达式: | 示意, 或: str.spilt(",|."); 依据 逗号 或 句号 拆分!

StringBuffer

StringBuffer:

• 咱们都晓得，String 类，并不适宜频繁的拼接， 每次拼接，其实是在 JVM 办法区中有反复创立一个 字符常量数组！
• Java.lang.StringBuffer 代表 可变的字符序列
  即，能够动静的拼接 String 而不会开拓新的空间耗费内存！
• 很多办法与 String 雷同，作为参数传递时，办法外部能够扭转值。

创立：

StringBuffer 类不同于 String，其对象必须应用结构器生成 有三个结构器

• StringBuffer() 初始容量为 16 的字符串缓冲区
  实质上 StringBuffer 底层也是一个 字符数组，但不是常量数组长度能够动静扭转的 默认长度 16
• StringBuffer(int size) 结构指定容量的字符串缓冲区
• StringBuffer(String str) 将内容初始化为指定字符串内容 String s = new String(“ 我喜爱学习 ”);

StringBuffer 类的罕用办法:

StringBuffer s = new StringBuffer();             // 申明一个空 StringBuffer 对象; 底层相当于 new char[16];
StringBuffer s = new StringBuffer("ABC");         // 申明一个字符串 "ABC", 底层相当于 new char["abc".length()+16];
总而言之：就是会, 预存多几个地位, 供增加, 如果还是超过了 16, 释怀不会越界, 反而它还会变大. 主动扩容原长度 *2... 哈哈.
    留神的是 s.length(); 长度还是你自身的字符长度....

StringBuffer        .toString();                                 // 将 StringBuffer 类型字符串 转换为 String 类型对象返回; Object 类办法 一些写类重写了其办法(自定义类也能够重其办法);
StringBuffer        .append(String);                             // 拼接指定字符串效率高.. 在 char[]数组后增加..
StringBuffer        .insert(int 地位, 参数);                         // 在字符串指定地位 int 中插入参数; 参数能够实 String 任何类型....;
StringBuffer        .delete(int start,int end);                    // 删除指定地位的内容
StringBuffer         .replace(int start, int end, String str)；// 把 [start,end) 地位替换为 str 
StringBuffer         .reverse();                                    // 把以后字符串逆转！

StringBuilder

StringBuilder 和 StringBuffer 十分相似，均代表可变的字符序列，而且 提供相干性能的办法也一样

总结：

String、StringBuffer、StringBuilder

• 三者都是操作字符串的一品种：
• String(JDK1.0)：不可变字符序列
• StringBuffer(JDK1.0)：可变字符序列、效率低、线程平安
• StringBuilder(JDK 5.0)：可变字符序列、效率高、线程不平安

三者执行效率：

• String < StringBuffer < StringBuilder

留神：
作为参数传递的话，办法外部 String 不会扭转其值，StringBuffer 和 StringBuilder 会扭转其值
String 是一种非凡的 援用类型 , StringBuffer 和 StringBuilder 相当于还是一种 援用类型的对字符串操作的一品种！

JDK8 之前的日期工夫 API

世界工夫：

工夫是一个十分形象的概念，多少年来，吸引着有数科学家、物理学家、甚至哲学家破费毕生精力去解释工夫的实质是什么

• 这里咱们不探讨高深莫测的学术常识，只把眼光放聚焦在计算机这个很小的领域内。
• 具体能够理解这里(大佬~)

计算世界工夫的次要规范:

UTC Coordinated Universal Time

• 世界规范工夫：
• 协调世界时是以原子时秒长为根底，国内原子时的准确度为每日数纳秒，原子钟 当初咱们应用的互联网就采纳该计时规范
• 经谨严计算失去的工夫，准确到秒，误差在 0.9s 以内，是比 GMT 更为准确的世界工夫

GMT Greenwich Mean Time

• 格林威治工夫
• 英国伦敦格林威治定为 0°经线开始的中央，地球每 15°经度 被分为一个时区，共分为 24 个时区，相邻时区相差一小时
  中国北京位于东八区，GMT 工夫比北京工夫慢 8 小时
• 格林尼治规范工夫的正午是指当太阳横穿格林尼治子午线时（也就是在格林尼治上空最高点时, 工夫

CST Central Standard Time

• 中亚工夫 中国: 北京工夫~
• 四个不同时区的缩写：
  Central Standard Time (USA) UTC-6:00 美国规范工夫
  Central Standard Time (Australia) UTC+9:30 澳大利亚规范工夫
  China Standard Time UTC+8:00 中国规范工夫
  Cuba Standard Time UTC-4:00 古巴规范工夫

在 Java8 之前工夫 API：

• java.util.Date: 示意 Java 中的日期，然而可能操作到工夫级别，
  现在这个类中的很多办法都曾经被废除，不倡议应用；
  Date 次要负责存储一个相对工夫 并对两边提供操作接口
• java.sql.Date: 示意数据库工夫，只能操作到日期，不能读取和批改工夫；
• java.sql.Time: 示意数据库工夫；
• java.sql.Timestamp: 工夫戳；
• Calendar: 工具类，提供工夫的加减等简单操作，反对时区；
  Calendar 负责对 Date 中特定信息，比方这个工夫是该年的第几个星期
  此外，还能够通过 set,add,roll 接口来进行日期工夫的增减
• TimeZone: 示意时区；
• SimpleDateFormat：日期格式化类，十分罕用
  SimpleDateFormat 次要作为一些格式化的输入输出

Date java.util 包

结构器：

java.util 包提供了 Date 类来封装以后的日期和工夫 Date 类提供两个构造函数来实例化 Date 对象

第一个构造函数应用以后日期和工夫来初始化对象
new Date();

第二个构造函数接管一个参数，该参数是从 1970 年 1 月 1 日起的毫秒数。new Date(long l);

第三个还有很多结构器被 @Deprecated 被 Java 过期注解标记为, 以过期了... "并不是不能应用, 而是不倡议应用... 曾经过期了."
@Deprecated
public Date(int year, int month, int date){...}            "该结构器输出的 年月日 创立日期对象, year month 并不精确存在偏移量！" 
                                                            应该是这个被淘汰了吧, JDK8 呈现 LocalDate "和他性能相似！"
...

罕用办法：

long         getTime( )                返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象示意的毫秒数。String         toString( )                把此 Date 对象转换为以下模式的 String
                                    dow mon dd hh:mm:ss zzz yyyy 其中：dow 是一周中的某一天 (Sun, Mon, Tue, Wed, Thu, Fri, Sat)
boolean     after(Date date)        若当调用此办法的 Date 对象在指定日期之后返回 true, 否则返回 false
boolean     before(Date date)        若当调用此办法的 Date 对象在指定日期之前返回 true, 否则返回 false
int         compareTo(Date date)    比拟当调用此办法的 Date 对象和指定日期。两者相等时候返回 0, 
                                    调用对象在指定日期之前则返回正数
                                    调用对象在指定日期之后则返回负数    
boolean     equals(Object date)        Date 重写的 Object 类的办法！使其比拟的不在是地址！

Demo:

package com.wsm.date;
import java.util.Date;

/**
 * Java.util.Date 工夫类的应用:
 */
public class DateDemo {public static void main(String[] args) {
        //Java.util 包提供了 Date 类来封装以后的日期和工夫
        //Date 类提供两个构造函数来实例化 Date 对象

        //new Date(); 结构器;
        Date d1 = new Date();           // 默认获取以后日期;
        System.out.println("new Date():\t"+d1);         //Date 类默认重写的 toString(); 不间接打印地址！但, 因为 Java 是老外开发的, 日期格局并不符号中国~

        //new Date(Long l); 结构器;
        long l = System.currentTimeMillis();    // 获取以后日期工夫戳.. 毫秒数~
        Date d2 = new Date(l);          // 依据: 给定的工夫戳, 获取指定日期...
        System.out.println("new Date(Long):\t"+d2);

        // 还有很多其它的结构器, 然而都过期了..
        //Java 注解: @Deprecated 正文的办法类, 示意 JDK 以过期不在保护的类, 但并不影响应用...!

        /**
         * Date 罕用办法：*/
        System.out.println("getTime():\t"+d1.getTime());       //getTime():  返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象, 示意的毫秒数;

        System.out.println("toString():\t"+d1.toString());      //toString(): 把此 Date 对象转换为以下模式的 String：dow mon dd hh:mm:ss zzz yyyy 格局;
        // dow 是一周中的某一天 (Sun, Mon, Tue,  Wed, Thu, Fri, Sat)
        // zzz 是工夫规范,

        /** 其它很多办法都过期了 */
    }
}

Java.sql.Date

实例化 和 sql.Date 和 util.Date 互相转换；

package com.wsm.date;

import java.util.Date;

/**
 * java.sql.Date 对应着数据库中的日期类型的变量
 *      java.sql.Date extends java.util.Date  继承 Util.Date
 */
public class SqlDateDemo {public static void main(String[] args) {
        // 创立 java.sql.Date 对象:
        // 对应数据中的日期变量！` 尽管如此然而如同还是很少应用, 个别也间接应用 util.Date`
        java.sql.Date date = new java.sql.Date(35235325345L);  // 它只蕴含日期而没有工夫局部, 输入时候只显示年月日！System.out.println(date);                              //1971-02-13

        /** 如何将 java.util.Date 对象转换为 java.sql.Date 对象 */
        // 状况一:
        //sql.Date 实质上继承了 util.Date
        Date date1 = new java.sql.Date(2343243242323L);         // 子类赋值父类
        java.sql.Date dateS = (java.sql.Date) date1;            // 而后在强转回, 因为 date1 原本就是 sql.Date 类型 能够强转回 sql.Date;
        System.out.println(dateS);

        
        /** 运行报错！父类前置转换成子类... */
        // 状况二:
//        java.sql.Date date2 = (java.sql.Date)new Date();        // 父类间接强转子类, 编译不报错运行报错
        // 因为:
        //      子类间接向上转换成父类, 并能够强转回子类:
        //          子类自身继承父类领有父类的属性办法, 自身属于 父类 / 子类能够来回转换！//      但:
        //          子类继承父类, 能够申明本人特有的办法属性... 父类间接转换子类, 可能回不存在特有的属性办法(); 故程序报错！/** java.util.Date 对象转换为 java.sql.Date 对象 */
        // 状况三:
        //      util.Date 存在一个办法 getTime(); 返回, 以后对象工夫戳。// 而:   sql.Date  刚好构造函数, 能够通过.. 工夫戳申明！Date date3 = new Date();
        java.sql.Date date4 = new java.sql.Date(date3.getTime());
        System.out.println("Java.util.Date:"+date3);
        System.out.println("Java.sql.Date:"+date4);
    }
}

总结：

sql.Date 自身继承于 util.Date：领有 util.Date 的属性办法..

• sql.Date 是为了，和数据库的日期类型进行匹配赋值应用, 但理论开发中更多还是 util.Date
• sql.Date 格局只能是：年月日
• util.Date 格局能够是：年月日时分秒 …

Java.text.SimpleDateFormat

Date 类的 API 不易于国际化，大部分被废除了

• SimpleDateFormat 是对日期类 Date 的格式化 和 解析;
  Date 类型的 toString 输入的是英文格局的工夫，而不同国家有本人的日期格局 …

  • SimpleDateFormat 就能够以特定的规定进行日期的 格式化 Format

SimpleDateFormatDemo

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

/**
 * SimpleDateFormat 类:
 *      Date 类的格式化 —— 解析
 *      格式化：日期 ---> 字符串
 *      解析：格式化的逆过程，字符串 ---> 日期
 *
 */
public class SimpleDateFormatDemo {public static void main(String[] args) throws ParseException {
        // 实例化 SimpleDateFormat: 应用默认的结构器
        SimpleDateFormat sdf = new SimpleDateFormat();  /** 默认的解析规定就是：(两位)年 月 日 ... */

        // 格式化：日期 ---> 字符串
        Date date = new Date();
        System.out.println(date);

        // 格式化~
        String format = sdf.format(date);
        System.out.println(format);

        // 解析：格式化的逆过程，字符串 ---> 日期
        Date date1 = sdf.parse(format);             /** 须要解决异样: 这里就 throws 抛出了~ */
        System.out.println(date1);

        /** 应用最多... */
        //************* 依照指定的形式格式化和解析：调用带参的结构器 *****************
//        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyyy.MMMMM.dd GGG hh:mm aaa");
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        // 格式化
        String format1 = sdf1.format(date);
        System.out.println(format1);
        // 解析: 要求字符串必须是合乎 SimpleDateFormat 辨认的格局(通过结构器参数体现),
        // 否则，抛异样~
        Date date2 = sdf1.parse("2020-02-18 11:48:27");
        System.out.println(date2);
    }
}

日期和工夫的格式化编码

java.util.Calendar 日历类

Calendar 是一个抽象类，主用用于实现日期字段之间互相操作的性能

• Calendar 实例的办法
  1. 应用 Calendar.getInstance() 办法
  2. 调用它的子类 GregorianCalendar 的结构器
• 一个 Calendar 的实例是零碎工夫的形象示意，通过 get(int field)办法来获得想要的工夫信息
  常量： YEAR年 、MONTH 月、DAY_OF_WEEK这一周第几天 、HOUR_OF_DAY 这一月第几天 MINUTE 分钟 、SECOND 秒
通过 get(常量); 获取指定的~
• 罕用办法
  public final Date getTime()
  public void set(int field,int value)
  public void add(int field,int amount)
  public final void setTime(Date date)

留神：

• 获取月份时：一月是 0，二月是 1，以此类推，12 月是 11
  获取星期时：周日是 1，周二是 2，。。。。周六是 7

CalendarDemo.Java

import java.util.Calendar;
import java.util.Date;

/** 日历类对象 Calendar 应用；*/
public class CalendarDemo {public static void main(String[] args) {
        //1. 实例化
        // 形式一：创立其子类（GregorianCalendar）的对象
//        Calendar gregoriancalendar = new GregorianCalendar();

        // 形式二：调用其静态方法 getInstance()
        Calendar calendar = Calendar.getInstance();                 // 获取以后日期的: Calendar 日历对象！//        System.out.println(calendar.getClass());

        //2. 罕用办法
        //get():
        //  依据常量参数, 获取对应的日期值~
        int days = calendar.get(Calendar.DAY_OF_MONTH);             // 获取当月的第几天~
        System.out.println("当月的第"+days+"天");                                   // 打印！System.out.println("当年的第"+calendar.get(Calendar.DAY_OF_YEAR)+"天");     // 获取当年的第几天~

        //set()
        //calendar 可变性
        //  给以后日历对象 进行年月赋值 返回值 void: 间接返回给以后对象赋值~
        calendar.set(Calendar.DAY_OF_MONTH,22);                     // 给以后日历对象设置为: 当月第 22 天
        days = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println("批改日历为当月, 第"+days+"天");                                   // 打印: 22

        //add(): 给以后日历对象进行 + - 操作
        calendar.add(Calendar.DAY_OF_MONTH,-3);
        days = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println(days);                                   // 打印: 22-3

        //getTime(): 日历类 ---> Date
        //  依据以后日历对象的工夫, 返回一个 Date 类型数据~
        Date date = calendar.getTime();
        System.out.println(date);

        //setTime():Date ---> 日历类
        //  将一个 Date 类型数据, 转换为: 日历对象！Date date1 = new Date();
        calendar.setTime(date1);
        days = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println(days);
    }
}

JDK8 新增的日期工夫 API

前言：

Java8 之前的日期，Date JDK1.0 时引入 根本能够满足根本的需要。
但，咱们心愿工夫能够与昼夜 节令 四季无关，JDK1.1 引入了 Calendar 类

• 而 Calendar 类并不比 Date 类好多少，它们面临的问题

• 可变性：

  calendar.set(Calendar.DAY_OF_MONTH,22);                     // 给以后日历对象设置为: 当月第 22 天
  Calendar 类的:
      Set(); 办法, 赋值会间接扭转以后的类对象, 这在 Java 被成为 "可变性"

• 偏移性：

  JDK8 之前工夫的类 Date 类其实是存在一个结构器："能够间接年月日返回 Date 对象..."
  但
  Date 中的年份是从 1900 开始的，而月份都从 0 开始, "间接赋值年月日, 实际上返回的日期并不精确,Date 是存在偏移量的！"
  
  //JDK8 之前日期问题...Date 存在便宜量~
  @Test
  public void offsetDate(){SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
  
      //Date(year, month, date);
      Date d1 = new Date(2000, 9, 9);     // 创立一个 2020 9 月 9 日的日期对象;
      System.out.println("Date 类存在偏移量:");
      System.out.println("未设置偏移量输入:"+sdf.format(d1));
  
      // 设置便宜量:
      //Date 正因为存在偏移量, 而被淘汰！而年便宜了 1900 年 月默认从 0 开始~ 所以 2020 09 09  应该这个样写！Date d2 = new Date(2000-1900, 9-1, 9);
      System.out.println("设置偏移量输入:"+sdf.format(d2));   // 失常输入 20200909
  }
  
  
  // 控制台输入：Date 类存在偏移量:
  未设置偏移量输入:3900-10-09
  设置偏移量输入: 2000-09-09

• 格式化：
  格式化只对 Date 有用，Calendar 则不行。此外，它们也不是线程平安的；不能解决闰秒等。

Java8 新增 API

对日期和工夫的操作始终是 Java 程序员最苦楚的中央之一
因而：

• Java8 之前呈现了，Joda-Time.Jar 包 周大 - 泰~ 来更不便的操作，日期 API
• 而后，JDK8 之后，为了不便用户操作，间接集成了该 Jar 包的性能！
  不在须要用户，每次都要引入 Joda-Time.Jar 依赖~
  当然如果，你当初公司是 Java7 你还想用这些工夫 ApI 还须要引入 Joda-Time.Jar 包
• 本地日期（LocalDate）
  本地工夫（LocalTime）
  本地日期工夫（LocalDateTime）
  时区（ZonedDateTime）
  ….
• 为了不便操作，古老的 Data 类 Java8 之后，也新增了 toInstant() 办法;
  用于将，Date 转换成新的示意模式，这些新增的本地化工夫日期 API 大大简化了日期工夫和本地化的治理。

LocalDate / Time / DateTime

LocalDate、LocalTime、LocalDateTime

• LocalDate、LocalTime、LocalDateTime 类是其中较重要的几个类 它们的实例 是不可变的对象
• 别离示意应用 ISO-8601 日历零碎的日期、工夫、日期和工夫
  它们提供了简略的本地日期或工夫，并不蕴含以后的工夫信息，也不蕴含与时区相干的信息
• LocalDate 代表 IOS 格局（yyyy-MM-dd）的日期, 能够存储 生日、纪念日等日期
• LocalTime 示意一个工夫，而不是日期
• LocalDateTime 是用来示意日期和工夫的，这是一个最罕用的类之一

ISO

• ISO 国际标准化组织(International Organization for Standardization
  

  罕用办法

  办法	形容
  now() now(ZoneId zone)	静态方法，依据以后工夫创建对象 / 指定时区的对象
  of()	静态方法，依据指定日期 / 工夫创建对象
  getDayOfMonth()<br/>getDayOfYear()	取得月份天数(1-31) / 取得年份天数(1-366)
  getMonthValue() <br/>getYear()	取得月份(1-12) / 取得年份
  getHour() getMinute() getSecond()	取得以后对象对应的小时、分钟、秒
  withDayOfMonth() withDayOfYear() withMonth() withYear()	将月份天数、年份天数、月份、年份批改为指定的值并返回新的对象
  plusDays() plusWeeks() plusMonths() plusYears() plusHours()	向以后对象增加几天、几周、几个月、几年、几小时
  minusMonths() minusWeeks() minusDays() minusYears() minusHours()	从以后对象减去几月、几周、几天、几年、几小时

Demo

LocalDateTimeDemo.Java

import org.junit.Test;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.util.Date;

/**
 * JDK8 之后的日期 API
 *      LocalDate       年月日~
 *      LocalTime       时分秒~
 *      LocalDateTime   年月日时分秒~
 *      三者, 办法相似, 都是 JDK8 之后新增的日期类, 别离用于示意不同的工夫 日期 工夫日期 形容的 Java 对象！*/
public class LocalDateTimeDemo {/** LocalDate LocalTime LocalDateTime 应用 / 罕用办法();
     *      LocalDateTime 相较于 LocalDate、LocalTime，应用频率要高
     *      相似于 Calendar
     * */
    public static void main(String[] args) {//now(): 获取以后的日期、工夫、日期 + 工夫
        LocalDate localDate = LocalDate.now();
        LocalTime localTime = LocalTime.now();
        LocalDateTime localDateTime = LocalDateTime.now();

        System.out.println("localDate:\t"+localDate);
        System.out.println("localTime:\t"+localTime);
        System.out.println("localDateTime:\t"+localDateTime);
        /** 三个类重写了 toString(); 间接输出的就是中国的日期格局~ */


        //of(): 设置指定的年、月、日、时、分、秒。没有偏移量
        LocalDateTime localDateTime1 = LocalDateTime.of(2020, 10, 6, 13, 23, 43);
        System.out.println(localDateTime1);


        //getXxx()：获取相干的属性
        System.out.println(localDateTime.getDayOfMonth());      // 获取以后日是这个月的第几天
        System.out.println(localDateTime.getDayOfWeek());       // 获取以后工夫是一周中的哪一天
        System.out.println(localDateTime.getMonth());           // 获取以后月份
        System.out.println(localDateTime.getMonthValue());      // 获取月份信息
        System.out.println(localDateTime.getMinute());          // 获取分钟
        /** 三个类均可调用相似的办法~ 留神要存在合乎的条件~ */

        /** 体现不可变性 */
        //withXxx(): 设置相干的属性
        //  LocalDate 对象通过 withxx(); 给日期对象设置日期属性, 然而, 并不会扭转以后对象, 而是会返回一个对象, 是更高后的日期~ 本类并不会收受到影响~
        LocalDate localDate1 = localDate.withDayOfMonth(22);
        System.out.println("更新前对象:"+localDate);
        System.out.println("更新后对象:"+localDate1);

        //plusxxx();    向以后对象增加几天、几周、几个月、几年、几小时
        LocalDateTime localDateTime3 = localDateTime.plusMonths(3);
        System.out.println(localDateTime);
        System.out.println(localDateTime3);

        //minusxxx();   向以后对象增加几天、几周、几个月、几年、几小时
        LocalDateTime localDateTime4 = localDateTime.minusDays(6);
        System.out.println(localDateTime);
        System.out.println(localDateTime4);
    }
    
    //JDK8 之前日期问题...Date 存在便宜量~
    @Test
    public void offsetDate(){SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

        //Date(year, month, date);
        Date d1 = new Date(2000, 9, 9);     // 创立一个 2020 9 月 9 日的日期对象;
        System.out.println("Date 类存在偏移量:");
        System.out.println("未设置偏移量输入:"+sdf.format(d1));

        // 设置便宜量:
        //Date 正因为存在偏移量, 而被淘汰！而年便宜了 1900 年 月默认从 0 开始~ 所以 2020 09 09  应该这个样写！Date d2 = new Date(2000-1900, 9-1, 9);
        System.out.println("设置偏移量输入:"+sdf.format(d2));   // 失常输入 20200909
    }
}

Instant

Instant

• 工夫线上的一个刹时点。这可能被用来记录应用程序中的事件工夫戳

  罕用办法

  办法	形容
  now()	静态方法，返回默认 UTC 时区的 Instant 类的对象 UTC 即本初子午线的工夫... 与北京工夫, 存在偏差~
  ofEpochMilli(long epochMilli)	静态方法，返回在 1970-01-01 00:00:00 根底上加上指定毫秒 数之后的 Instant 类的对象
  atOffset(ZoneOffset offset)	联合即时的偏移来创立一个 能够通过它来, 向东偏移 8 示意东八区北京工夫!
  OffsetDateTime toEpochMilli()	返回 1970-01-01 00:00:00 到以后工夫的毫秒数，即为工夫戳

  Demo

  InsantDemo.Java

  import java.time.Instant;
  import java.time.OffsetDateTime;
  import java.time.ZoneOffset;
  
  /***
   * Instant 类的 Demo 学习
   *
   */
  public class InsantDemo {public static void main(String[] args) {//now(): 获取本初子午线对应的规范工夫
        Instant instant = Instant.now();
        System.out.println(instant);//2019-02-18T07:29:41.719Z      //
  
        // 北京世界东八区！1949 年起的逾半世纪，在中国大陆、台湾、香港、澳门所应用的规范工夫皆为东八区（UTC+8）工夫
        // 中国, 占五个时区. 别离是东 5 区 东 6 区 东 7 区 东 8 区 东 9 区 据北京较远的地区也有不应用北京工夫的 比方乌鲁木齐工夫就是东九区工夫, 比北京工夫早一个小时 世界分 24 个时区
  
        // 增加工夫的偏移量
        OffsetDateTime offsetDateTime = instant.atOffset(ZoneOffset.ofHours(8));
        System.out.println(offsetDateTime);//2019-02-18T15:32:50.611+08:00
  
        //toEpochMilli(): 获取自 1970 年 1 月 1 日 0 时 0 分 0 秒（UTC）开始的毫秒数  ---> Date 类的 getTime()
        long milli = instant.toEpochMilli();
        System.out.println(milli);
  
        //ofEpochMilli(): 通过给定的毫秒数，获取 Instant 实例  -->Date(long millis)
        Instant instant1 = Instant.ofEpochMilli(1550475314878L);
        System.out.println(instant1);
    }
  }

  DateTimeFormatter

  DateTimeFormatter

  该类提供了三种格式化办法：

• 预约义的规范格局
  就是默认的日期格式化~ 不须要任何指定~
• 本地化相干的格局
  提供了几种定义好的枚举，格式化类型~ 年月日时分秒 yyyy-MM-DD HH:mm:ss
• 自定义的格局
  通过：ofPattern(yyyymm); 来指定日期的格局~

罕用办法：

• 格式化： 将日期(对象) 转换为字符串~
• 解析： 将字符串日期转换为~ 日期对象 转换的字符 和 日期对象的格局要统一, 不然转换失败！

Demo

DateTimeFormatterDemo.Java

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.time.format.FormatStyle;
import java.time.temporal.TemporalAccessor;

/** DateTimeFormatter */
public class DateTimeFormatterDemo {public static void main(String[] args) {
//      形式一：预约义的规范格局。如：ISO_LOCAL_DATE_TIME;  ISO_LOCAL_DATE;   ISO_LOCAL_TIME       散布对应三个对象！DateTimeFormatter formatter = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
        // 格式化: 日期 --> 字符串
        LocalDateTime localDateTime = LocalDateTime.now();
        String str1 = formatter.format(localDateTime);
        System.out.println(localDateTime);
        System.out.println(str1);//2019-02-18T15:42:18.797
        // 解析：字符串 --> 日期
        TemporalAccessor parse = formatter.parse("2019-02-18T15:42:18.797");
        System.out.println(parse);

        
//      形式二：//      本地化相干的格局。如：ofLocalizedDateTime()
//      FormatStyle.LONG / FormatStyle.MEDIUM / FormatStyle.SHORT : 实用于 LocalDateTime
        DateTimeFormatter formatter1 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.LONG);
        // 格式化
        String str2 = formatter1.format(localDateTime);
        System.out.println(str2);//2019 年 2 月 18 日 下午 03 时 47 分 16 秒

//      本地化相干的格局。如：ofLocalizedDate()
//      FormatStyle.FULL / FormatStyle.LONG / FormatStyle.MEDIUM / FormatStyle.SHORT : 实用于 LocalDate
        DateTimeFormatter formatter2 = DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM);
        // 格式化
        String str3 = formatter2.format(LocalDate.now());
        System.out.println(str3);//2019-2-18


//       重点：形式三：自定义的格局。如：ofPattern(“yyyy-MM-dd hh:mm:ss”)
        DateTimeFormatter formatter3 = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss");
        // 格式化
        String str4 = formatter3.format(LocalDateTime.now());
        System.out.println(str4);//2019-02-18 03:52:09

        // 解析
        TemporalAccessor accessor = formatter3.parse("2019-02-18 03:52:09");
        System.out.println(accessor);
    }
}

总结：

Java8 新增了很多的日期 API 其实罕用的也就以上 …

• Java8 之前的其实还有很多人应用，JDK 是向下兼容的，所以不用放心
• 但，8 据说效率还挺高，而且的确挺不便的 …

JDK8 其它 API

System Java 零碎类：

java.lang 包下 的一个 零碎类，能够通过该类获取的以后计算机的：属性~

• 该类的结构器是 private 的 所以无奈创立该类的对象，也就是无奈实例化该类.
  其外部的成员变量和成员办法都是 static 的，所以也能够很不便的进行调用

成员变量

• System 类外部蕴含 in、out 和 err 三个成员变量
  别离代表规范输出流 (键盘输入)
  规范输入流 (显示器)
  规范谬误输入流(显示器)

成员办法

Sacnner 扫描器：

java.util.Scanner 是 Java5 的新特色，咱们能够通过 Scanner 类来获取用户的控制台输出
须要搭配 System.in 的输出流~ Scanner s = new Scanner(System.in);

罕用办法：

如果要输出 int 或 float 类型的数据，在 Scanner 类中也有反对
next.Byte() nextDouble() nextFloat,nextInt() nextLin() nextLong() nextShot()
然而在输出之前最好先应用 hasNextXxx() 办法进行验证，再应用 nextXxx() 来读取，不然输出 int 的输出了一个 String 会报错~

 /** 成员属性: in out err */
     //in:   配合 Scanner 扫描器, 能够实现控制台的输出流...
     //out:  这个, 最罕用: System.out.print(); 返回一个输入流, 输入信息
     //err:  和 out 相似, 然而它输入的信息个别示意谬误, 比拟显眼的 红色信息！// 创立一个扫描仪
 Scanner scanner = new Scanner(System.in);
 System.out.println("请输出一段话 s1:");
 String s1 = scanner.next();
 System.out.println("请输出一段话 s2:");
 String s2 = scanner.next();
 System.err.println("s1:"+s1);
 System.err.println("s2:"+s2);
 // 留神: 不要同时两个
 // scanner.nextxxx() 写在一起, 这些办法执行时都会造成梗塞，期待用户在命令行输出数据回车确认.
 // 写在一起, 输出了一个回车, 则所有的 nextxxx() 都完结了！scanner.close();                /** 要留神敞开流 o 不然占用程序资源... */

SystemDemo

SysDemo.Java

import java.util.Scanner;

/**
 * System 零碎类的学习...
 */
public class SysDemo {
    //main 主办法...
    public static void main(String[] args) {

        /** 成员属性: in out err */
            //in:   配合 Scanner 扫描器, 能够实现控制台的输出流...
            //out:  这个, 最罕用: System.out.print(); 返回一个输入流, 输入信息
            //err:  和 out 相似, 然而它输入的信息个别示意谬误, 比拟显眼的 红色信息！// 创立一个扫描仪
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输出一段话 s1:");
        String s1 = scanner.next();
        System.out.println("请输出一段话 s2:");
        String s2 = scanner.next();
        System.err.println("s1:"+s1);
        System.err.println("s2:"+s2);
        // 留神: 不要同时两个
        // scanner.nextxxx() 写在一起, 这些办法执行时都会造成梗塞，期待用户在命令行输出数据回车确认.
        // 写在一起, 输出了一个回车, 则所有的 nextxxx() 都完结了！scanner.close();                /** 要留神敞开流 o 不然占用程序资源... */

        /** currentTimeMillis */
        long timeStamp = System.currentTimeMillis();    // 返回以后工夫, 工夫戳;
        // 工夫戳: 值以后日期间隔, 格林威治工夫(GMT)1970-01-01  的毫秒数~
        // 应用:
        //  通常能够, 用于生产一个工夫戳, 工夫惟一的一个 ID, 用作在数据库 / 文件名... 示意数据惟一~
        System.out.println(timeStamp);


        /** getProperty(): 获取零碎的参数信息！*/
        String javaVersion = System.getProperty("java.version");
        System.out.println("java 的环境版本:" + javaVersion);

        String javaHome = System.getProperty("java.home");
        System.out.println("java 的装置门路:" + javaHome);

        String osName = System.getProperty("os.name");
        System.out.println("操作系统的名称:" + osName);

        String osVersion = System.getProperty("os.version");
        System.out.println("操作系统的版本:" + osVersion);

        String userName = System.getProperty("user.name");
        System.out.println("计算机用户账户名:" + userName);

        String userHome = System.getProperty("user.home");
        System.out.println("用户的主目录:" + userHome);

        String userDir = System.getProperty("user.dir");
        System.out.println("用户当前工作目录:" + userDir);
    }
}

Math Java 数学类：

Java 的 Math 蕴含了用于执行根本数学运算的属性和办法，如初等指数、对数、平方根和三角函数
Math 的办法都被定义为 static 模式，通过 Math 类能够在主函数中间接调用 不必 new 能够间接调用！

罕用办法：

MathDemo

MathDemo.Java

public static void main(String[] args) {
/** 算术计算 */
    System.out.println("-------- 算术计算 -----------");
    System.out.println(Math.sqrt(16));          // 4.0      4^2 4 的二次方 =16
    System.out.println(Math.cbrt(8));           // 2.0      2^3 2 的三次方 = 8
    System.out.println(Math.pow(3, 2));         // 9.0      3^2 3 的二次方 =16     几次方就是, x 乘 x 次! 3x3=9
    System.out.println(Math.max(2.3, 4.5));     // 4.5      判断最大值！System.out.println(Math.min(2.3, 4.5));     // 2.3      判断最小值！/**
     * abs 求绝对值: 就是把一个数变成 + 负数！*/
    System.out.println(Math.abs(-10.4));        // 10.4
    System.out.println(Math.abs(10.1));         // 10.1

/** 进位 */
    System.out.println("-------- 进位 -----------");
    /**
     * ceil 天花板的意思，就是逢余进一
     *      负数 +1
     *      小数 +1, 小数 +1~
     */
    System.out.println("--------ceil-----------");
    System.out.println(Math.ceil(-10.1));       // -10.0
    System.out.println(Math.ceil(10.7));        // 11.0
    System.out.println(Math.ceil(-0.7));        // -0.0
    System.out.println(Math.ceil(0.0));         // 0.0
    System.out.println(Math.ceil(-0.0));        // -0.0
    System.out.println(Math.ceil(-1.7));        // -1.0

    /**
     * floor 地板的意思，就是逢余舍一
     */
    System.out.println("--------floor-----------");
    System.out.println(Math.floor(-10.1));      // -11.0
    System.out.println(Math.floor(10.7));       // 10.0
    System.out.println(Math.floor(-0.7));       // -1.0
    System.out.println(Math.floor(0.0));        // 0.0
    System.out.println(Math.floor(-0.0));       // -0.0

    /**
     * rint 四舍五入，返回 double 值 留神.5 的时候会取偶数 异样的难堪 =。=
     */
    System.out.println("--------rint-----------");
    System.out.println(Math.rint(10.1)); // 10.0
    System.out.println(Math.rint(10.7)); // 11.0
    System.out.println(Math.rint(11.5)); // 12.0
    System.out.println(Math.rint(10.5)); // 10.0
    System.out.println(Math.rint(10.51)); // 11.0
    System.out.println(Math.rint(-10.5)); // -10.0

    /**
     * round 四舍五入，float 时返回 int 值，double 时返回 long 值
     */
    System.out.println("--------round-----------");
    System.out.println(Math.round(10)); // 10
    System.out.println(Math.round(10.1)); // 10
    System.out.println(Math.round(10.7)); // 11
    System.out.println(Math.round(10.5)); // 11
    System.out.println(Math.round(10.51)); // 11
    System.out.println(Math.round(-10.5)); // -10
}

获取 100 以内的随机数！

 @Test
  /** 获取 100 以内的随机数！*/
  public void randomHundred(){// Math.random() 获取 0 -1 的随机数! 蕴含 0!
      System.out.println("随机 0 -1");
      System.out.println(Math.random());

      System.out.println("随机 0 -100");
      System.out.println((int)(Math.random()*100)+1);
      /**
       * (int)(Math.random()*100)+1
       *  因为: Math.random() 获取 0 -1 的随机数! 蕴含 0!
       *      *100 获取随机数进两位小数, 强制转换(int) 会截取小数点..
       *      因为蕴含 0 所以 +1 就不会呈现呢 0 的状况了！！！*/
  }

BigInteger 与 BigDecimal 类：

BigInteger

Java.math 包
Interger 类作为 int 的包装类，能存储的最大整型值为 2^{31-1}
Long 类也是无限的，最大为 2^{63-1}

• 如果要示意再大的整数，不论是根本数据类型还是他们的包装类都无能为力，更不用说进行运算了
• BigInteger 提供所有 Java 的根本整数操作符的对应物
  并提供 Java.lang.Math 的所有相干办法
• BigInteger 还提供以下运算：
  模算术、GCD 计算、质数测试、素数生成、位操作以及一些其余操作

结构器

• BigInteger(String val)：依据字符串构建 BigInteger 对象

罕用办法：

BigInteger abs()                      返回大整数的绝对值
BigInteger add(BigInteger val)         返回两个大整数的和
BigInteger and(BigInteger val)      返回两个大整数的按位与的后果
BigInteger andNot(BigInteger val)     返回两个大整数与非的后果
BigInteger divide(BigInteger val)      返回两个大整数的商
double doubleValue()                   返回大整数的 double 类型的值
float floatValue()                   返回大整数的 float 类型的值
BigInteger gcd(BigInteger val)      返回大整数的最大公约数
int intValue()                         返回大整数的整型值
long longValue()                     返回大整数的 long 型值
BigInteger max(BigInteger val)         返回两个大整数的最大者
BigInteger min(BigInteger val)         返回两个大整数的最小者
BigInteger mod(BigInteger val)         用以后大整数对 val 求模
BigInteger multiply(BigInteger val) 返回两个大整数的积
BigInteger negate()                 返回以后大整数的相反数
BigInteger not()                     返回以后大整数的非
BigInteger or(BigInteger val)         返回两个大整数的按位或
BigInteger pow(int exponent)         返回以后大整数的 exponent 次方
BigInteger remainder(BigInteger val)返回以后大整数除以 val 的余数
BigInteger leftShift(int n)         将以后大整数左移 n 位后返回
BigInteger rightShift(int n)         将以后大整数右移 n 位后返回
BigInteger subtract(BigInteger val)    返回两个大整数相减的后果
byte[] toByteArray(BigInteger val)    将大整数转换成二进制反码保留在 byte 数组中
String toString()                     将以后大整数转换成十进制的字符串模式
BigInteger xor(BigInteger val)         返回两个大整数的异或

BigDecimal

Decimal：[中：小数]
个别的 Float 类和 Double 类能够用来做科学计算或工程计算
但在商业计算中，要求数字精度比拟高，故用到 Java.math.BigDecimal类
BigDecimal 类反对不可变的、任意精度的有符号十进制定点数

结构器

• public BigDecimal(double val)
• public BigDecimal(String val)

罕用办法

add(BigDecimal)            BigDecimal 对象中的值相加，而后返回这个对象。subtract(BigDecimal)     BigDecimal 对象中的值相减，而后返回这个对象。multiply(BigDecimal)      BigDecimal 对象中的值相乘，而后返回这个对象。divide(BigDecimal)         BigDecimal 对象中的值相除，而后返回这个对象。toString()              将 BigDecimal 对象的数值转换成字符串。doubleValue()              将 BigDecimal 对象中的值以双精度数返回。floatValue()            将 BigDecimal 对象中的值以单精度数返回。longValue()             将 BigDecimal 对象中的值以长整数返回。intValue()              将 BigDecimal 对象中的值以整数返回

Java 的 flot double 计算有问题:

查看上面的代码：

 @Test
  public void bigDecimal(){System.out.println(0.1+0.2);
      System.out.println(0.3-0.1);
      System.out.println(0.2*0.1);
      System.out.println(0.3/0.1);
  }

因为不论是 float 还是 double 都是浮点数，而计算机是二进制的，浮点数会失去肯定的精确度

• 根本原因是: 十进制值通常没有完全相同的二进制示意模式
• 十进制数的二进制示意模式可能不准确。只能有限靠近于那个值

但：

• 在我的项目中，咱们不可能让这种状况呈现，特地是金融我的项目

• 如果你的支付宝账户余额显示 193.99999999999998，那是一种怎么样的体验？ 😁

  ---