当先锋百科网

首页 1 2 3 4 5 6 7

初识JAVA14:Math类、基本数据类型的包装类、枚举类、Date类、SimpleDateFormat类

初识JAVA14

Math数据相关类

静态工厂

public class Demo {
    public static void main(String[] args) {
        //static int abs(int a) 返回 int值的绝对值。
        System.out.println(Math.abs(-3));

        //static double ceil(double a) 向上取整   返回>=参数的最近的整数
        System.out.println(Math.ceil(2.2));
        System.out.println(Math.ceil(2.0));
        System.out.println(Math.ceil(-1.8));

        //static double floor(double a)  向下取整 返回小于或等于参数且等于数学整数的最大值（最接近正无穷大） double 。
        System.out.println(Math.floor(-1.9));

        //static double max(double a, double b) 返回两个 double值中较大的 double 。
        System.out.println(Math.max(2.1,3.1));
        System.out.println(Math.min(2.1,3.1));

        //static double pow(double a, double b) 返回第一个参数的值，该值是第二个参数的幂。
        System.out.println(Math.pow(2,3));

        //随机数: static double random() 返回带有正号的 double值，大于或等于 0.0且小于 1.0 。
        System.out.println(Math.random());
        System.out.println(Math.random());
        System.out.println(Math.random());
        System.out.println(Math.random());

        //随机整数 [min,max)  (int)(Math.random() * (max-min) + min)
        //推到过程:
        //[min,max)  Math.random()-->[0.0,1.0)
        //[min,max)  Math.random() * max -->[0.0,max)
        //[min,max)  Math.random() * max + min -->[min,max+min)
        //[min,max)  Math.random() * (max-min) + min -->[0,max-min) +min --> [min,max)

        //随机整数 [min,max]  (int)(Math.random() * (max-min+1) + min)
        //[5,8]
        System.out.println((int)(Math.random() * (8-5+1) + 5));
        System.out.println((int)(Math.random() * (8-5+1) + 5));
        System.out.println((int)(Math.random() * (8-5+1) + 5));

        //static long round(double a) 返回与参数最接近的 int ，并将关系四舍五入为正无穷大。  -->小数点后1位四舍五入
        System.out.println(Math.round(2.5));
        System.out.println(Math.round(2.49));

        //static double sqrt(double a) 返回 double值的正确舍入正平方根。
        System.out.println(Math.sqrt(9));

    }
}

基本数据类型的包装类

为什么存在存在基本数据类型还要提供引用数据类型?

​ 1.包装类是类,类中可以定义成员,增强使用能力(成员变量,成员方法…)

​ 2.类似集合,要求只能存储引用数据类型的数据

​ 3.基本数据类型与引用数据类型的默认值(null)

为什么存在包装类还要保留基本数据类型?

​ 基本数据类型比引用数据类型更节省内存空间,存在性能优势

基本数据类型包装类
byteByte
shortShort
intInteger
longLong
floatFloat
doubleDouble
charCharacter

包装类具有自动拆装箱的功能:

​ 自动装箱:基本—>包装

​ 自动拆箱:包装—>基本

public class Demo {
    public static void main(String[] args) {
        int a = 1000;
        //此方法已经过时,不推荐使用
        Integer in = new Integer(1000);

        //自动装箱,将字面常量转换为Integer类型的对象
        Integer in2 = 1000;

        //基本--->包装
        Integer i1 = new Integer(a);    //通过构造方法
        Integer i2 = Integer.valueOf(a);    //通过静态方法

        //包装--->基本
        int b = i1.intValue();
        
        //自动拆箱,在参与基本数据类型计算时,Integer类型自动拆箱为基本数据类型
        int sum = a+in2;
        System.out.println(sum);

        System.out.println(in2.equals(a));  //true

        //Integer类型和基本数据类型比较时会自动拆箱,比较数值的大小
        System.out.println(a == in2);   //true

        //引用类型变量之间使用==比较的是对象的地址是否相等
        System.out.println(in == in2);  //false


    }
}

整数缓冲区

整数缓冲区:-128~127共256个整数,是最常用的整数

在整数缓冲区中已经预先创建好了这256个整数,若新建的Integer对象在这个区间内,则会直接从整数缓冲区中获取,而不是创建新的对象

只有使用了new关键字,就一定会创建新的对象,不会再从缓冲区中获取

public class Demo {
    public static void main(String[] args) {
        //在[-128,127]区间内
        Integer i1 = 127;
        Integer i2 = 127;
        System.out.println(i1==i2); //直接从缓冲区中获取,true

        //不在[-128,127]区间内
        Integer i3 = 128;
        Integer i4 = 128;
        System.out.println(i3==i4); //创建新的对象,false

        //在[-128,127]区间内,但使用了new关键字创建了新的对象
        Integer i5 = new Integer(-128);
        Integer i6 = new Integer(-128);
        System.out.println(i5==i6); //false
    }
}

枚举类

enum,当能够确定一种事物的所有的可能,一个类型的所有对象的时候使用枚举类

定义枚举类型 enum 类名{}

java中所有的枚举类型都会隐式的继承自java.lang.Enum,这是所有java枚举类型的公共基类.

枚举类中的字段,就作为当前枚举类型的一个实例存在,默认被public static final修饰

package com.xxx.learn.enumlearn;
/*
定义一个员工类,
    员工姓名,年龄,工号,入职年份,薪资,员工工作状态(忙碌,空间,正常)
    找到找到2021年入职的员工,打印
    找到工作状态忙碌的员工,薪资涨%6
 */
public class UserEnum {
    public static void main(String[] args) {
        User[] userArr = new User[]{
                new User("张三",20,1,"2015-1-1",10000,UserState.BUSY),
                new User("李四",21,2,"2010-1-1",5000,UserState.NORMAL),
                new User("王五",30,3,"2021-1-1",8000,UserState.FREE)
        };

        for(User user:userArr){
            if("2021".equals(user.getDate().split("-")[0])){
                System.out.println(user);
            }
            //UserState.BUSY会返回实例的名字BUSY,所以可以写为user.getState().equals(UserState.BUSY)
            if(user.getState()==UserState.BUSY){
                user.setSalary(user.getSalary()*(1+0.06));
                System.out.println(user);
            }
        }
    }
}

class User{
    private String name;
    private int age;
    private int id;
    private String date;
    private double salary;
    //使用枚举类型作为User的属性
    private UserState state;

    public User() {
    }

    public User(String name, int age, int id, String date, int salary, UserState state) {
        this.name = name;
        this.age = age;
        this.id = id;
        this.date = date;
        this.salary = salary;
        this.state = state;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public int getId() {
        return id;
    }

    public String getDate() {
        return date;
    }

    public double getSalary() {
        return salary;
    }

    public UserState getState() {
        return state;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", id=" + id +
                ", date='" + date + '\'' +
                ", salary=" + salary +
                ", state=" + state +
                '}';
    }
}

enum UserState{
    BUSY,
    FREE,
    NORMAL;
}

/*
    BUSY("忙碌"),FREE("空闲"),NORMAL("正常");
	//枚举类中也可以存在属性
    private String name;
	//枚举类的构造方法只能被private修饰
    private State(){}
    private State(String name){
        this.name = name;
    }
*/

/*
普通类想要实现枚举类的过程
class WDay{
    //实例
    public static final WDay MON = new WDay("星期一");
    public static final WDay SUN = new WDay("星期天");

    String name;

    private WDay(){}
    private WDay(String name){
        this.name = name;
    }
}
*/

Date类

日期类型:

​ Date日期

​ Date类表示特定的时刻，精度为毫秒。

需要import java.util.Date;

package com.xxx.demo;

import java.util.Date;

public class Demo {
    public static void main(String[] args) {
        //获取本地当前时间
        Date date = new Date();
        System.out.println(date);
        //返回从纪元开始到目前位置过去的毫秒数
        System.out.println(date.getTime());
        //Date对象并初始化它以表示自标准基准时间（称为“纪元”）以来的指定毫秒数，即1970年1月1日00:00:00 GMT。
        Date date2 = new Date(1623570084467L);
        System.out.println(date2);//Sun Jun 13 15:41:24 CST 2021
        //boolean after(Date when) 测试此日期是否在指定日期之后。
        System.out.println(date.after(date2));
        //boolean before(Date when) 测试此日期是否在指定日期之前。
        System.out.println(date.before(date2));
    }
}

SimpleDateFormat类

格式日期转换器,可以实现日期与字符串之间转换的问题

import java.text.SimpleDateFormat;

format() 日期对象转换字符串

parse() 字符串转为日期对象

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

public class Demo {
    public static void main(String[] args) throws ParseException {
        //获取本地当前时间
        Date date = new Date();
        System.out.println(date);
        //创建一个yyyy-MM-dd HH:mm:ss SSS格式的SimpleDateFormat对象
        SimpleDateFormat s = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
        //s.format(date)将date对象转换为yyyy-MM-dd HH:mm:ss SSS格式的字符串并返回
        System.out.println(s.format(date));
        //s.parse("2021-06-13 15:48:03 306")将字符串转换为date对象并返回,需要编译前处理异常,抛出或try{}cash{}
        System.out.println(s.parse("2021-06-13 15:48:03 306"));
    }
}