Java常用包装类

前言

Java的4类8种基本数据类型，功能过于单一无法满足快速开发需要。

JDK1.8中自带了大量Java包装类， 这些包装类在基本数据类的基础上进行了大量功能封装。

学习和使用包装类，避免了重复造轮子，达成敏捷开发的目的。

一、引入包装类

1.包装类是什么？

之前我们定义变量，只能使用Java基本数据类型，这些基本数据类型有4类八种。

• 1  整型：    byte 、short 、int 、long 
• 2  浮点型：float 、 double 
• 3 字符型：char
• 4 布尔型：boolean

对于这些基本数据类型来说，它们值就是1个数字。没有任何方法和属性，不方便我们使用和操作。

所以为了使基本数据类型拥有面向对象的特征，功能更加丰富，Java对它的基本数据类型进行进一步的功能封装，就产生了包装类。

包装类被封装在Java的lang包里，这就意味着我们无需导入直接使用；

2.包装类有哪些？

对应以上的四类八种基本数据类型，包装类有以下。

 

二、Integer类

Integer类是对int基本数据类型的封装。

package CommonClass;

public class Test01 {
    public static void main(String[] args) {
        //Interger的属性
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);
        //物极必反
        System.out.println(Integer.MAX_VALUE + 1);
        System.out.println(Integer.MIN_VALUE - 1);
        //字符串转换成数字
        Integer i1 = new Integer("12");
        Integer i2 = Integer.parseInt("12");
        System.out.println(i1 + i2);
        //自动装箱和自动拆箱：int类型和Integer类型之间可以进行快速的类型转换
        Integer i3 = new Integer(12);
        int num4 = i3;
        System.out.println(num4);
        //Interger的方法:返回3种结果：小于返回-1/等于返回0/大于返回1
        int num5 = i1.compareTo(i2 + i2);//(x < y) ? -1 : ((x == y) ? 0 : 1);
        System.out.println(num5);
        //equals：Integer类虽然继承了Object类，但是对Object的equals()进行了重新，比较的是底层封装的值，而不是内存地址。
        //如果Integer的值在-128到127之间比较值，否则比较对象的地址
        Integer i7 = 22;
        Integer i8 = 22;
        System.out.println(i7 == i8);
        System.out.println(i7.equals(i8));

        //intValue():将integer转换为int类型
        int i9 = i8.intValue();
        System.out.println(i9);

        //toString():把integer转换为String类型    
        System.out.println(i7.toString());


    }
}

三、时间日期类

在编程的过程中，我们经常从前端或者数据库获取到字符串类型的时间。

这时我们就需要把String类型的时间字符串，转换成便于Java处理的时间格式。

或者把Java中的时间类型，转成字符串响应给浏览器或者存储到数据库。 

所以每1种编程语言都会有一种String<====>Date之间的转换机制。

1.java.util.Date

java.util.Date是java中最常用的时间类型，以下的几个时间相关类，我们都围绕java.util.Date展开。

package DateClass;

import java.util.Date;

public class Test {
    public static void main(String[] args) {
        Date d = new Date();
        System.out.println(d);
        System.out.println(d.toLocaleString());//2021-11-2 10:17:24
        System.out.println(d.getYear());
        System.out.println(d.getMonth());
        System.out.println(d.getTime()); //时间戳：               1635819720476
        System.out.println(System.currentTimeMillis()); //时间戳：1635819720523

        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 100000; i++) {
            System.out.println(i);
        }
        long endTime = System.currentTimeMillis();
        System.out.println(endTime - startTime);


    }
}

2.java.sql.Date

package CommonClass;

import java.sql.Date;

public class Test02 {
    //导入import java.sql.Date;
    public static void main(String[] args) {
        //sql.Date继承至java.util.Date；public class Date extends java.util.Date
        Date d = new Date(1635820261871L);
        System.out.println(d);
        /*
         *(1)java.util.Date和java.sql.Date的区别？
         *java.util.Date:年月日 时分秒
         * java.sql.Date:只有年月日
         *
         * (2)java.util.Date和java.sql.Date的联系？
         *java.util.Date是java.sql.Date的父类：java.sql.Date继承至java.util.Date
         *
         *(3)java util.Date和java.sql.Date相互转换。
         *java.util.Date转换成java.sql.Date
         *
         *
         * */
        //java.util.Date转换成java.sql.Date类型
        java.util.Date date = new java.sql.Date(1635820261871L); //创建java.util.Date的对象
        //方式1：向下转型：就是把父类强转成子类
        java.sql.Date date1 = (java.sql.Date) date; //把java.util.Date转换成java.sql.Date
        System.out.println(date1);

        //方式2：利用构造器
        Date date2 = new Date(date.getTime());
        //java.sql.Date转换成java.sql.util类：向上转换，父类引用指向子类对象，是自动进行的！
        java.util.Date date3 = new java.sql.Date(1635820261871L);


    }
}

3.String转换成java.util.Date类型

日常开发过程中，我们经常需要把字符串（String）转换成时间类型。

package CommonClass;

public class Test03 {
    public static void main(String[] args) {
        //(1)String转成java.sql.Date
        java.sql.Date date=java.sql.Date.valueOf("2015-6-25");
        //(2)java.sql.Date转成java.util.Date
        java.util.Date date1=date;
        System.out.println(date.getTime());
        //以上代码有局限性，字符串的格式只能是年-月-日(2015-6-25)形式，换成其他格式(2015/6/25)就会出现以下异常。
        /*
        * Exception in thread "main" java.lang.IllegalArgumentException
            at java.sql.Date.valueOf(Date.java:143)
            at CommonClass.Test03.main(Test03.java:6)
        * */
    }
}

以上代码有局限性，字符串的格式只能是年-月-日(2015-6-25)形式，如果是其他格式(2015/6/25)就会出现以下异常。

 Exception in thread "main" java.lang.IllegalArgumentException
            at java.sql.Date.valueOf(Date.java:143)
            at CommonClass.Test03.main(Test03.java:6)

4.自定时间转换格式

我们可以自定义一种时间格式，用于完成Date和String之间的相互转换；

package CommonClass;

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

public class Test03 {
    public static void main(String[] args) {

        //1.自定义一种时间格式化标准
        DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //2.使用parse把String转成java.util.Date
        try {
            Date date = df.parse("2019-04-06 12:23:54");
            System.out.println(date);
        } catch (ParseException e) {
            System.out.println("转换失败");
        }
        System.out.println(df);
        //3.使用format把Date(java.util.Date)转成String
        String curentTime = df.format(new Date());
        System.out.println(curentTime);


    }
}

5.Calendar

我们可以使用Calendar类获取当前时间的年月日，也可以给Calendar设置一个其他的时间。

package CommonClass;

import java.util.Calendar;
import java.util.GregorianCalendar;

public class Test04 {
    public static void main(String[] args) {
        //1.Calendar是一个抽象类，不可以直接创建对象
        Calendar cal = new GregorianCalendar();
        Calendar cal2 = Calendar.getInstance();
        System.out.println(cal);

        //2.Calendar常用的方法
        //2.1get方法
        System.out.println(cal.get(Calendar.YEAR));
        System.out.println(cal.get(Calendar.MONTH));
        System.out.println(cal.get(Calendar.DATE));
        System.out.println(cal.get(Calendar.DAY_OF_WEEK)); //获取星期
        //获取当月日期的最大天数
        System.out.println(cal.getActualMaximum(Calendar.DATE));
        //获取当月日期的最小天数
        System.out.println(cal.getActualMinimum(Calendar.DATE));

        //2.2 set方法:可以改变Calendar中的年、月、日等时间信息
        cal.set(Calendar.YEAR, 1993);
        cal.set(Calendar.MONTH, 6);
        cal.set(Calendar.DATE, 28);
        System.out.println(cal.get(Calendar.YEAR)); //获取年
        System.out.println(cal.get(Calendar.MONTH));//获取月
        System.out.println(cal.get(Calendar.DATE)); //获取日

        //String--->Calendar的转换
        java.sql.Date date = java.sql.Date.valueOf("2020-02-20");
        cal.setTime(date);//把时间设置成2020-02-20
        System.out.println(cal.get(Calendar.YEAR));
        System.out.println(cal.get(Calendar.MONTH));
        System.out.println(cal.get(Calendar.DATE));

    }
}

6.日历

package CalendarClass;

import java.util.Calendar;
import java.util.Scanner;
import java.util.Calendar;

public class Test01 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("请录入你想要查看的日期 例如 2021-02-22的格式：");
        String strDate = sc.next();
        java.sql.Date sqlDate = java.sql.Date.valueOf(strDate);
        Calendar cal = Calendar.getInstance();
        cal.setTime(sqlDate);
        //获取今天是几号
        int currentDay = cal.get(Calendar.DATE);
        //获取本月的最大天数
        int maxDay = cal.getActualMaximum(Calendar.DATE);
        //将日期调为本月1号
        cal.set(Calendar.DATE, 1);
        //获取本月的1号是星期几
        int firstDayOfWeek = cal.get(Calendar.DAY_OF_WEEK) - 1;

        int counter = 0;
        System.out.println("日	一	二	三	四	五	六	");
        for (int i = 0; i < firstDayOfWeek; i++) {
            System.out.print("	");
        }
        counter = counter + firstDayOfWeek;
        for (int i = 1; i < maxDay; i++) {
            if (i == currentDay) {
                System.out.printf("*%d	", i);
            } else {
                System.out.printf("%d	", i);
            }
            counter++;
            if (counter % 7 == 0) {
                System.out.println();
            }
        }


    }
}

7.LocalDateTime

JDK1.0中使用的java.util.Date类，属于第一批日期时间API

JDK1.1引入Calendar类，属于第二批日期时间API

但是JDK1.1有以下缺陷

可变性：像日期和时间这样的类应该是不可变的。

偏移性：Date中的年份是从1900开始，而月份是从0开始。

格式化：格式化只对Date有用，Calendar则不行。

在JDK1.8之后新增了第3批日期时间API，LocalDate、LocalTime、LocalDateTime。

package CommonClass;

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

public class Test05 {
    public static void main(String[] args) {
        //1.完成实例化
        //方法1：now():获取当前的日期，时间，日期+时间
        LocalDate localDate = LocalDate.now();  //2021-11-04
        System.out.println(localDate);
        LocalTime localTime = LocalTime.now(); //15:03:35.536
        System.out.println(localTime);
        LocalDateTime localDateTime = LocalDateTime.now(); //2021-11-04T15:03:35.537
        System.out.println(localDateTime);
        //方法2：of():设置日期，时间，日期+时间
        LocalDate of = LocalDate.of(2010, 5, 6);
        System.out.println(of);
        LocalTime of1 = LocalTime.of(12, 35, 56);
        System.out.println(of1);
        LocalDateTime of2 = LocalDateTime.of(2010, 12, 16, 23, 3);
        System.out.println(of2);

        //LocalDate和LocalTime用的不如LocalDateTime多
        //get()
        System.out.println(localDateTime.getYear());       //年
        System.out.println(localDateTime.getMonth());      //月
        System.out.println(localDateTime.getMonthValue()); //月份数字
        System.out.println(localDateTime.getDayOfMonth()); //日
        System.out.println(localDateTime.getDayOfWeek());  //星期几
        System.out.println(localDateTime.getHour());    //时
        System.out.println(localDateTime.getMinute());  //分
        System.out.println(localDateTime.getSecond());  //秒

        //with：
        LocalDateTime localDateTime1 = localDateTime.withMonth(12);
        System.out.println(localDateTime1);
        //LocalDateTime使用with()修改时间，修改的是1个新的对象。具有不可变性
        System.out.println(localDateTime);


        //LocalDateTime提供了加、减操作
        LocalDateTime localDateTime2 = localDateTime.plusMonths(4);//4个月之后
        System.out.println(localDateTime2);
        LocalDateTime localDateTime3 = localDateTime.minusMonths(4); //4个月之前
        System.out.println(localDateTime3);


    }
}

8.DateTimeFormatter

我们可以使用DateTimeFormatter，完成LocalDateTime和String之间的相互转换。

package CommonClass;

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

public class Test06 {
    public static void main(String[] args) {

        //方式一：
        //formatter可以帮助我们完成LocalDateTime和String之间的相互转换
        DateTimeFormatter formatter = DateTimeFormatter.ISO_DATE_TIME;
        //LocalDateTime-->String
        LocalDateTime now = LocalDateTime.now();
        String dateString = formatter.format(now);
        System.out.println(dateString);  //2021-11-04T16:00:02.718
        //String-->LocalDateTime
        TemporalAccessor date = formatter.parse("2021-11-04T16:00:02.718");
        System.out.println(date);

        //方式二：
        //参数：
        /*
         FormatStyle.LONG--2021年11月4日  长格式
         FormatStyle.MEDIUM---2021-11-4   中格式
         FormatStyle.SHORT:21-11-4        短格式
        */
        DateTimeFormatter formatter1 = DateTimeFormatter.ofLocalizedDate(FormatStyle.SHORT);
        //LocalDateTime-->String
        LocalDateTime now1 = LocalDateTime.now();
        String dateString1 = formatter1.format(now1);
        System.out.println(dateString1);
        //String-->LocalDateTime
        TemporalAccessor date1 = formatter1.parse("21-11-4");
        System.out.println(date1);


        //方式三：较为常用
        DateTimeFormatter formatter2 = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss");
        //LocalDateTime-->String
        LocalDateTime now2 = LocalDateTime.now();
        String dateString2 = formatter2.format(now2);
        System.out.println(dateString2); //2021-11-04 04:15:22
        //String-->LocalDateTime
        TemporalAccessor date2 = formatter2.parse("2021-11-04 04:15:22");
        System.out.println(date2);


    }
}

四、Math类 

Math类是封装在java.lang中常用类，对外提供一些数学运算的API。

package CommonClass;

// import static java.lang.Math.*;
// 静态导入时：如果本类中有静态方法和导入的包同名，会优先执行本类中的静态方法，遵循就近原则。
public class Test07 {
    public static void main(String[] args) {
        //math常用属性
        System.out.println(Math.PI);
        //math常用方法
        System.out.println("随机数" + Math.random());//随机返回0.0 -1.0之间的小数
        System.out.println("绝对值" + Math.abs(-90));
        System.out.println("向上取值" + Math.ceil(9.1));  //天花板：ceiling
        System.out.println("向上取值" + Math.floor(9.9)); //地板：floor
        System.out.println("四舍五入" + Math.round(3.8));
        System.out.println("比较2数取大" + Math.max(6, 9));
        System.out.println("比较2数取小" + Math.min(6, 9));
    }
}

五、随机数生成

java.util.Random类可以帮我们生成随机数字。

package CommonClass;

import java.util.Random;

public class Test08 {
    public static void main(String[] args) {
        //学习Math.random()返回带正号的double值，该值大于等于0.0且小于1.0
        System.out.println(Math.random());
        //学习Random类
        //(1) 利用带参数构造器创建对象
        Random r1 = new Random(System.currentTimeMillis());
        int x = r1.nextInt();
        System.out.println(x);
        //（2） 利用空参构造器创建对象：实际底层还是调用了参数为纳秒的有参构造器。
        Random random = new Random();
        //返回大于等于0且小于10的整数
        System.out.println(random.nextInt(10));
        //返回大于等于0.0且小于1.0的值
        System.out.println(random.nextDouble());

    }
}

参考