JavaSE| 包装类| 时间

包装类

* 因为Java是面向对象的语言，所以很多API或新特性都是针对“对象”来设计的，但是Java设计之初时，是C语言很盛行的时候，所以Java保留了C语言中的8种基本数据类型，
  保留它们有好处，速度快，计算方便，每一种数据类型都有固定的大小...

 * 如果我们的数据使用了8种基本数据类型的变量来保存，后面有想使用Java中只针对“对象”来设计的很多API或新特性时，Java就为8种基本数据类型设计它们的包装类。
 *
 * 只针对“对象”来设计的很多API或新特性
 * 例如：集合，泛型只针对引用数据类型
 *
 * 包装类：为了包装基本数据类型的数据为“对象”。
 * byte->Byte
 * short->Short
 * int->Integer
 * long->Long
 * float->Float
 * double->Double
 * char->Character
 * boolean->Boolean

装箱：把基本数据类型的数据“包装”为对象，称为装箱                装的目的是为了使用只针对“对象”来设计的很多API或新特性
　　　　手动装箱：Integer i = new Integer(num);
　　　　自动装箱: Integer j = int的值或变量;  JDK1.5之后是自动装箱、拆箱； 
　　Double d = (double) 10; 左边的d是Double包装类型,右边10如果是int类型是无法自动装箱的，要先转成double类型；

拆箱：把包装类的对象“拆开”为基本数据类型的数据，称为拆箱        拆的目的是为了计算简便，高效

　　    手动拆箱： int num = Integer的对象.intValue();
　　    自动拆箱：
 * 说明：不管是拆箱还是装箱都是对应类型之间的，即 int -> Integer;  double -> Double

 * java中数据类型的转换：
 * 1、基本数据类型之间的转换：自动类型转换与强制类型转换
 * 2、父子类之间转换：向上转型与向下转型
 * 3、包装类与基本数据类型之间：装箱与拆箱

以Integer为例

java.lang包下：
 *
 * 以：Integer为例
 * 1、常量
 * Integer.MAX_VALUE
 * Integer.MIN_VALUE
 *
 * 2、方法
 * （1）比较包装类对象的大小
 * int compareTo(xx) 必须是相同类型之间进行； 如：   i.compareTo(i2);  即i比i2大多少？  做减法运算，i与i2都是包装类对象的相同类型
 *
 * （2）和String类型的转换
　　 A：从String的对象 -> 包装类的对象
　　　　 "123" ->Integer.valueOf(字符串)
　　　　　　　　　 new Integer( str )；

　　 B：从String的对象 -> 基本数据类型
　　　　 "123" -> 123      如： int i = Integer.parseInt(str);
　　　 　int       Integer.parseInt(字符串)
　　
　　 C：把包装类的对象->字符串   in1.toString();
　　　　    toString()
 　　
　　 D：把基本数据类型 -》字符串
　　　　    + ""  字符串的拼接；
 　　
　　（3）转成各种进制的形式

　　　　System.out.println("二进制：" + Integer.toBinaryString(num));
　　　　System.out.println("八进制：" + Integer.toOctalString(num));
　　　　System.out.println("十六进制：" + Integer.toHexString(num));

 * 基本数据类型之间的比较： ==  比较的是数据值
 * 包装类之间的比较： ==  比较的是地址值，但推荐使用 equals
 *
 * 原因是包装类对象，有一部分是缓存对象，（常量对象） ；在缓存对象范围内比较，两个包装类对象的地址值都是相同的；超过这个范围或者没有范围的，地址值就不一样了
 * Byte：-~
 * Short：-~
 * Integer：-~
 * Long：-~
 *
 * 没有缓存对象：
 * Float
 * Double
 *
 * Character：~  最早ASCII码的范围128个字符
 * Boolean：true,false

                Double d1 = 20.1;
        Double d2 = 20.1;
        System.out.println(d1==d2);//false

        Integer i11 = ;
        Integer i12 = ;
        System.out.println(i11==i12); //true
        System.out.println(i11.equals(i12));//true

Object类、 Arrays类、scanner类、Math类

java.lang.Object类：
 * （）Class getClass()：获取当前对象的运行时类型
 * （）void finalize()：当对象要被垃圾回收器回收时，垃圾回收器负责调用，每个对象只调用一次
 * （）boolean equals(Object o)：用来比较当前对象和指定对象是否“相等”，默认情况下，和==一样比较对象的地址，子类可以重写。
 *         重写时注意：
 *         （）和hashCode()一起重写，选择的属性一样
 *         （）遵循：自反性、传递性、一致性、对称性，非空对象与空对象比较返回false
 * （）int hashCode()：每个对象都会通过散列函数计算出一个int 整数值，支持此方法是为了提高哈希表等的性能。
 *         特点：两个对象如果相等，他们的hashCode值一定相等。
 *             如果两个对象的hashCode值相等，这两个对象不一定相等。
 *             如果两个对象的hashCode值不相等，那么这两个对象一定不相等。
 * （）String toString()：把对象用字符串形式返回，默认返回“类型@对象的hash码的十六进制值”，子类建议重写。
 *
java.util.Arrays类：
 * （）static int binarySearch(Object[] a, Object key) ：在a数组中找key，如果存在返回下标，不存在返回“负数”,
 *     用于二分查找的数组一定是有序。
 *
 * （）static Object[] copyOf(Object[] original, int newLength) ：从original数组复制出一个新数组，新数组的长度是newLength。
 *     这个newLength可以<=original.length，也可以newLength>original.length，如果大于newLength>original.length，那么剩下的元素用默认值。
 *       默认值：
 *         byte,short,int,long：
 *         float,double:0.0
 *         char：\u0000
 *         boolean:false
 *         引用数据类型：null
 * （）static void sort(Object[] a) :对a数组进行排序，默认按照元素的“自然顺序”进行“升序”排序。
 *        static void sort(Object[] a, Comparator c) ：对数组a进行排序，按照定制比较器c，对元素进行“升序"排序。
 *
 * 自然排序：要求元素实现java.lang.Comparable接口，重写int compareTo(Object obj)
 * 定制排序：要求单独写个类实现java.util.Comparator接口，重写int compare(Object o1, Object o2)
 *
 * （）static String toString(Object[] a) ：把元素拼接为一个字符串："[元素1，元素2....]"
 *
 *
java.util.Scanner:
 * （）构造器
 *     Scanner input = new Scanner(System.in);
 * （）其他方法
 * 输入一个int的整数：int nextInt();
 * 输入一个double的小数：double nextDouble()
 * 输入一个boolean的值：boolean nextBoolean()
 * 输入一个字符串：String next()
 * 输入一个字符：没有现成的：从字符串中取出第一个字符
 *             input.next().charAt()

java.lang.Math：
 * （）static final double PI=...;
 * （）static double random()：产生[,)范围的小数
 * （）static double sqrt(x)：返回x的平方根
 

java.math包：
　　BigDecimal：大小数，精度要求特别长
　　BigInteger：大整数

java.lang.Math:
　 　ceil：天花板
　　 floor：地板
　　 round：舍入模式
　　
　　 max(x,y)
　　 min(x,y)

public class TestMath {
    @Test
    public void test1(){
        System.out.println(Math.ceil(2.5));//
        System.out.println(Math.floor(2.5));//
        System.out.println(Math.round(2.5));//
        System.out.println("--------------------");
        System.out.println(Math.ceil(-2.5));//-2
        System.out.println(Math.floor(-2.5));//-3
        System.out.println(Math.round(-2.5));//-2  round = floor(值+0.5)
        System.out.println("--------------------");
        System.out.println(Math.ceil(-2.6));//-2
        System.out.println(Math.floor(-2.6));//-3
        System.out.println(Math.round(-2.6));//-2  round = floor(值+0.5)
    }
}

System类

系统类java.lang.System：
 常量对象有三个
 * （1）System.out：打印普通信息  PrintStream
 * （2）System.err：打印错误信息  PrintStream
 * （3）System.in：默认情况下，代表键盘输入 InputStream
其他的方法：
 * （1）System.currentTimeMillis():当前时间与协调世界时 1970 年 1 月 1 日午夜之间的时间差（以毫秒为单位测量）。
　　　　　    --->>　1545061369999
 * （2）System.arraycopy(src, srcPos, dest, destPos, length)：
 *         如果src和dest是不同的数组，表示复制，从srt的[srcPos]开始，一共复制length个到dest的[destPos]开始存。
 *         如果src和dest是同一个数组，表示移动元素：
 *             如果srcPos > destPos：左移              一般用于删除
 *             如果srcPos < destPos：右移        一般用于插入
 *
 * (3)System.gc():表示通知垃圾回收器来回收垃圾，但不是立马响应，但是只要调用了，一定会来。
 *     开发是不建议手动调用gc()方法，因为垃圾回收算法已经很好了。
 * （4）System.exit(0):0表示正常退出
 *   System.exit(1)：1表示异常退出
 * （5）Properties getProperties()：  System.getProperties(); 获取系统属性
 

时间API

* JDK1.8之前：
java.util.Date:  类 Date 表示特定的瞬间，精确到毫秒。

 * (1)new Date()：获取系统时间
 * (2)new Date( 毫秒值 ):把毫秒转时间，Date类型的
 * (3)long getTime()：把时间转毫秒

　　　　　Date date = new Date();
        System.out.println(date); //Wed Dec 05 19:55:08 GMT+08:00 2018

        long time = date.getTime();
        long millis = System.currentTimeMillis();
        System.out.println(time); //
        System.out.println(millis);//

        System.out.println(new Date(Long.MAX_VALUE)); //Sun Aug 17 15:12:55 GMT+08:00 292278994

java.util.Calendar：日历类型； 它的子类：GregorianCalendar

 方法：
（1） Calendar getInstance()
（2） get(常量名)

　　　　Calendar c = Calendar.getInstance();//使用默认时区和语言环境获得一个日历

        int year = c.get(YEAR);
        int month = c.get(MONTH) + 1; //
        int day = c.get(DAY_OF_MONTH); //
        System.out.println(day); 

        int daysOfYear = c.get(DAY_OF_YEAR);
        System.out.println(year+"年" + month +"月" +day + "日是这一年的第" + daysOfYear);

        int hour1 = c.get(HOUR);//12小时制
        int hour2 = c.get(HOUR_OF_DAY);//24小时值

        System.out.println(hour2); 

        c.add(DAY_OF_MONTH, -50);//正数是往后推算日期，负数是往前推断日期

时区：了解
　　　　String[] all = TimeZone.getAvailableIDs();
　　　　TimeZone t = TimeZone.getDefault();
　　　　TimeZone t1 = TimeZone.getTimeZone("America/New_York");
　　　　Calendar c2 = Calendar.getInstance(TimeZone.getTimeZone("America/New_York"));

　日期时间的格式化：
　　1、把指定格式字符串转成日期时间对象
　　2、把日期时间对象转成指定格式字符串
　　
　　java.text.DateFormat
　　java.text.SimpleDateFormat
　　 
　　（1）Date parse(字符串) 字符串转成Date类型的
　　（2）String format(Date的日期对象) new SimpleDateFormate("yyyy-MM-dd HH:mm").formate(new Date());  Date类型转成字符串类型的

 

　　　　public static void main(String[] args) throws ParseException {
　　　　　　String str = "2018-12-4 19:44";
　　　　　　SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm");

　　　　　　Date date = sdf.parse(str);
　　　　　　System.out.println(date); //Tue Dec 04 19:44:00 GMT+08:00 2018
　　　　　　　System.out.println(sdf.format(new Date()));  // 转成字符串类型格式 --> 2018-12-17 23:36

　　　　　　Date now = new Date();
　　　　　　System.out.println(now); //Mon Dec 17 23:27:18 GMT+08:00 2018

　　　　　　SimpleDateFormat sf = new SimpleDateFormat("yyyy年MM月dd日 HH点mm分ss秒SSS毫秒 E");
　　　　　　String string = sf.format(now);
　　　　　　System.out.println(string); //2018年12月05日 20点34分36秒290毫秒 星期三

　　}

JDK1.8之前有关时间的API：
　　java.util.Date
　　java.util.Calendar
　　java.text.DateFormat和java.text.SimpleDateFormat
　　
　　java.sql.Date
　　java.sql.Timestamp
　　java.sql.Time
　　
老版的日期时间API：
 * （1）日期时间对象没有和String，Integer等一样设计为不可变。
 * 在实际开发中，认为某个日期时间对象，代表某个时间点后就不应该修改，修改应该产生新的对象。
 * （2）偏移性：Date中的年份是从1900开始的，而月份都是从0开始的。
 * （3）日期时间的格式化DateFormat没有提供支持Calendar，而API中建议使用Calendar来代替Date的很多已过时方法
 * （4）不能处理闰秒
 * （5）线程不安全
 * ...
JDK1.8时，
 * 1、LocalDate：只表示日期
 *   LocalTime：只表示时间
 *   LocalDateTime：可以表示日期和时间
 * （1）now()获取当前的日期或时间
 * （2）of(year,month,day)
 * （3）getXxx()
 * （4）修改日期，时间，会得到一个新的日期时间对象
　　 　　plusXxx
　　　　 minusXxx
　　 　　withXxx
 * （5）isLeapYear()
 *
 * 2、日期时间格式化

LocalDate、LocalTime、LocalDateTime

　　　　@Test
   　　 public void test2(){
        LocalDate today = LocalDate.now();
        System.out.println(today);//2018-12-17
        System.out.println(today.getMonth()); //DECEMBER
        System.out.println(today.getYear()+"年" + today.getMonthValue() +"月"+ today.getDayOfMonth() +"日" + ",过了" + today.getDayOfYear()+"天");
　　　　　　　　　　　　　　　　//2018年12月17日,过了351天

        System.out.println(LocalDate.of(2018, 12, 20).getDayOfYear()); //

        System.out.println(today.plusDays(30)); ////再过30天的日期
        today.minusDays(50);//50天前的日期
        today.withDayOfYear(200);//一年中第200天是什么日期
        System.out.println(today.isLeapYear()); //false

        System.out.println(LocalDateTime.now());//2018-12-17T23:50:09.662

        System.out.println(LocalTime.now()); //23:51:31.727

    }
    

日期时间格式

    @Test
    public void test3() throws ParseException{
        String str = "2018年12月11日";
        DateTimeFormatter df = DateTimeFormatter.ofPattern("yyy年MM月dd日");
        TemporalAccessor ta = df.parse(str);
        System.out.println(ta); //{},ISO resolved to 2018-12-11

        System.out.println(LocalDate.from(ta)); //2018-12-11

        System.out.println(new SimpleDateFormat("yyy年MM月dd日").parse(str));//Tue Dec 11 00:00:00 GMT+08:00 2018

    }

    @Test
    public void test4(){
        String str = DateTimeFormatter.ofLocalizedDate(FormatStyle.FULL).format(LocalDate.now());
        System.out.println(str);//2018年12月18日 星期二
        System.out.println( DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM).format(LocalDate.now()));//2018-12-18
    }