笔记: javaSE day17天笔记

程序员贺加贝

已于 2024-04-02 12:47:37 修改

阅读量664

点赞数 11

分类专栏： dljd 文章标签：笔记开发语言 java

于 2024-04-02 12:47:17 首次发布

本文链接：https://blog.csdn.net/qq_45481524/article/details/137265975

版权

dljd 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

第十七天课堂笔记

Java常用类

数学类★★★

math

java.lang.Math , 数学类
round(x) : 四舍五入 , 把 x加0.5 后向下取整
ceil(x) : 返回大于等于x的最小整数 , 向上取整
floor(x) : 返回小于等于x的最大整数 , 向下取整
sqrt(x) : 平方根
cbrt(x): 立方根
pow(a , b) : a的b次方
random: 返回[0 , 1) 返回内的随机数
max(a , b) , min(a , b) : 返回两个数中最大/最小值

代码如下:

public static void main(String[] args) {
        // random生成[0 , 1) 的随机数
        double random = Math.random();
        System.out.println("random = " + random);
        // 生成 [ min , max) 中的随机数
        int max = 10, min = 5;
        System.out.println("Math.random() * (max - min) + min = " + (Math.random() * (max - min) + min));

        // max(a,b) 返回较大值
        System.out.println("Math.max(123453, 543261) = " + Math.max(123453, 543261));

        // min(a , b) 返回较小数
        System.out.println("Math.min(123, 523) = " + Math.min(123, 523));

        // round(x) 四舍五入, x加上0.5后向下取整
        System.out.println("Math.round(3.5) = " + Math.round(3.5));
        System.out.println("Math.round(3.2) = " + Math.round(3.2));
        System.out.println("Math.round(-3.5) = " + Math.round(-3.5));  // -3
        System.out.println("Math.round(-3.9) = " + Math.round(-3.9));  // -4

        // ceil(x) 向上取整 : 返回大于等于x的最小整数
        System.out.println("Math.ceil(4.13) = " + Math.ceil(4.13));  // 5.0
        System.out.println("Math.ceil(-3.1) = " + Math.ceil(-3.1));  // -3.0

        // floor(x) 向下取整 : 返回小于等于x的最大整数
        System.out.println("Math.floor(3.6) = " + Math.floor(3.6));  // 3.0
        System.out.println("Math.floor(-3.6) = " + Math.floor(-3.6)); // -4.0

        // sqrt(a) 平方根
        System.out.println("Math.sqrt(100) = " + Math.sqrt(100)); // 10
        // cbrt(b) 立方根
        System.out.println("Math.cbrt(1000) = " + Math.cbrt(1000)); // 10
        // 次方pow
        System.out.println("Math.pow(2, 10) = " + Math.pow(2, 10)); // 1024

    }

random

java.util.Random : 随机数类
Random rnd = new Random() 创建随机数对象
rmd.nextInt() : 随机整数
rmd.nextDouble(): 随机小数
rmd.nextInt(limit) : [0 , limit) 的随机数 , limit > 0
jdk17新增方法
- nextInt(a , b) : [a , b)的随机数
- nextDouble(a . b): [a , b)随机小数

代码如下:

public static void main(String[] args) {
        // 创建随机数对象
        Random random = new Random();
        // 生成随机整数 nextInt()
        System.out.println("random.nextInt() = " + random.nextInt());
        // 生成随机小数 nextDouble()
        System.out.println("random.nextDouble() = " + random.nextDouble());

        // 生成[0 , bound) 的整数, 且 limit > 0
        System.out.println("random.nextInt(20) = " + random.nextInt(20));

        // 生成[0 , bound) 随机小数
        System.out.println("random.nextDouble(30) = " + random.nextDouble(30));

        // jdk17新增方法 , 生成[origin , bound)之间的随机数
        System.out.println("random.nextInt(10 , 20) = " + random.nextInt(10, 20));
    }

decimalformat

java.text : 把小数转换为指定格式的字符串
常见格式 :
- 0 : 数字 , 不够四位自动补零 , 够了四舍五入
- #: 数字
- , : 千位
- . : 小数点
构造: 调用构造方法创建 , new DecimalFormat(“###,###.0000”);
方法
- format(double) : 把小数根据定义的格式转换为字符串 : 小数 -> 格式化字符串
- applyPattern(“格式”) : 重新设置模式串

代码如下:

public static void main(String[] args) {
        // 调用,根据构造方法创建格式
        DecimalFormat decimalFormat = new DecimalFormat("###,###.0000");

        // 进行格式转换 , 0不够四位自动补零
        String format = decimalFormat.format(124322.445);
        System.out.println("format = " + format);

        // 从新设置模式串applyPattern
        decimalFormat.applyPattern("000,000.###");
        System.out.println("decimalFormat.format(1234.56) = " + decimalFormat.format(1234.56));

        System.out.println("decimalFormat.format(45678912.456789) = " + decimalFormat.format(45678912.456789));
    }

biginteger/bigdecimal

大的整数类/大的小数类
应用于精度要求比较高的场景
由于 int , long 整数取值受限 , 小数采用近似值保存不准确 => 采用有string参数的构造方法创建对象

方法

add() 加
subtract() 减
multiply() 乘
divide() 除
- 在大的小数的类中, 两个大的小数进行除操作, 当除不断的时候 , 会存在 java . lang.arithmeticException 算术异常
- 故需要调用的是 divisor(除数 , scale保留小数的位数 , roundingMode尾数的处理方式) 这个重载的方法
remainder() 取余

代码如下:

    public static void main(String[] args) {
        // 小数采用的近似值保存,不准确
        System.out.println(2 - 1.1);

        BigInteger b1 = new BigInteger("3124325452345543545265622524145415");
        BigInteger b2 = new BigInteger("54235346522451515154454");

        // 加add
        System.out.println("b1.add(b2) = " + b1.add(b2));
        // 减subtract
        System.out.println("b1.subtract(b2) = " + b1.subtract(b2));
        // 乘multiply
        System.out.println("b1.multiply(b2) = " + b1.multiply(b2));
        // 除divide
        System.out.println("b1.divide(b2) = " + b1.divide(b2));
        // 取余 remainder
        System.out.println("b1.remainder(b2) = " + b1.remainder(b2));

        // 大的小数
        BigDecimal d1 = new BigDecimal("1243676453213432545332143222.457644134532");
        BigDecimal d2 = new BigDecimal("1243676453414141343222.45764532");
        // 加add
        System.out.println("d1.add(d2) = " + d1.add(d2));
        System.out.println("d1.subtract(d2) = " + d1.subtract(d2));
        System.out.println("d1.multiply(d2) = " + d1.multiply(d2));
//        System.out.println("d1.divide(d2) = " + d1.divide(d2)); //.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result.
        System.out.println("d1.divide(d2, 10, RoundingMode.CEILING) = " + d1.divide(d2, 10, RoundingMode.CEILING));
        System.out.println("d1.remainder(d2) = " + d1.remainder(d2));
    }

枚举:

一组常量的组合 , 引用数据类型
使用情况: 当某个类型的 变量取值范围 只有几个离散值时
使用 enum关键字定义枚举类型
赋值 : 只能赋值枚举常量 , 枚举名.常量;
定义枚举类型后, 系统自动添加两个静态方法
- values() : 获得该枚举类中所有的枚举常量
- valueOf() : 将字符串转换为枚举常量

代码如下:

public static void main(String[] args) {
        Season spring = Season.SPRING;
        System.out.println("spring = " + spring);

        // 获取所有的枚举常量
        Season[] values = Season.values();
        for (Season value : values) {
            System.out.println(value);
        }
        // 将字符串类型转换成枚举常量
        String str = "WINTER";
        spring = Season.valueOf(str);
        spring = Season.SUMMER;
        System.out.println(spring);
    }

    // 定义一个枚举类型 , 定义季节枚举类型的常量值
    enum Season {
        SPRING, SUMMER, AUTUMN, WINTER;
    }

数据类型的作用
- 决定数据类型的存储方式
- 决定数据类型的取值范围
- 决定数据允许的操作

日期类★★★

Date

Java.util.Date 日期类 , 是线程不安全的
Date(long millis) : 根据毫秒值获取从1970-1-1年开始对应的时间
- CST: 中国标准时间
- millis 为负值时 : 获取的是从1970-1-1年开始往前对应的时间
getTime() : 获得date对象 从1970-1-1年开始 对应的毫秒数
时间戳:
- System.currentTimeMillis()
- new Date().getTime()
转换
- 时间对象 转换成指定格式 字符串 : SimpleDateFormat类
  - 先通过SimpleDateFormat(String pattern) 创建个对象并指定日期格式串
    - y年, M月 , d日 , H时 , m分 , s秒 , S毫秒
  - 调用该对象的 format( date )方法 , 将date对象时间 返回成一个字符串
- 字符串解析成时间对象
  - 首先也是通过SimpleDateFormat(String pattern) 创建对象并指定日期格式串
  - 调用该对象的parse( string ) 方法 , 将字符串安装格式解析成一个date对象
  - parse方法会存在parseException 解析异常 , 因为string的格式必须跟指定的日期格式串的格式保持一致

代码如下:

public static void main(String[] args) throws ParseException {
        // 创建date对象,返回当前时间
        Date date = new Date();
        System.out.println("date = " + date);

        // 通过date(long millis)构造方法 构造指定从1970年经过millis毫秒数的时间
        Date date1 = new Date(123445324543L);
        System.out.println("date1 = " + date1);

        // 负毫秒值情况 , 从1970年1月1向前查询毫秒值对应的时间
        Date date2 = new Date(-14353564543L);
        System.out.println("date2 = " + date2);

        // 获取时间对应的毫秒数 : getTime()
        System.out.println("date.getTime() = " + date.getTime());
        System.out.println("date1.getTime() = " + date1.getTime());
        System.out.println("date2.getTime() = " + date2.getTime());

        // 时间戳, 获取当前时间距离1970-1-1 00:00:00 经过的毫秒数
        long millis = System.currentTimeMillis();
        System.out.println("millis = " + millis);
        System.out.println("new Date().getTime() = " + new Date().getTime());

        // 格式化时间格式, 返回成指定的字符串 , y年, M月,d日, H小时,m分钟,s秒,S毫秒
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        // format() , 将时间转换成字符串打印 =  date -> string
        String formatDate = simpleDateFormat.format(date);
        System.out.println("formatDate = " + formatDate);

        // string -> date , 字符串解析date对象
        String strDate = "2024-04-01 11:19:20";
        // 使用parse(字符串)解析
        // Unhandled exception: java.text.ParseException 抛出处理
        // 当给定字符串格式 不符合定义格式java.text.ParseException: Unparseable date: "2024-04-01 11:19:20"
        Date date3Parse = simpleDateFormat.parse(strDate);
        System.out.println("date3Parse = " + date3Parse);

        // 当字符串没有该时间情况 , 会自动将时间往后顺延为合理时间
        String strDate1 = "2086-15-16 10:28:56";
        Date parse = simpleDateFormat.parse(strDate1);
        System.out.println("parse = " + parse);
    }

Calendar

Java.util.calendar日历类 , 是一个抽象类 , 故无法通过构造方法创建对象
创建对象: 通过**调用静态方法getInstance()**方法实现 -> Calendar.getInstance();

get(int field ): 返回指定字段值

field可以为 : 1-> 年 , 2 -> 月 . 5 -> 日 , 11 -> 小时 , 12 -> 分钟 . 13 -> 秒

同时, 也可以为Calendar提供的静态常量获取如

public static final int YEAR = 1;
public static final int MONTH = 2;
public static final int DATE = 5;
public static final int HOUR = 10;
public static final int HOUR_OF_DAY = 11;
public static final int MINUTE = 12;
public static final int SECOND = 13;

代码如下:

    public static void main(String[] args) {
        // Calendar是一个抽象类, 'Calendar' is abstract; cannot be instantiated
        //需要通过调用它的静态方法getInstance() 创建它的对象 ,->createCalendar(defaultTimeZone(aLocale), aLocale);
        Calendar calendar = Calendar.getInstance();
        // get方法 , 返回指定字段值
        System.out.println("calendar.get(1) = " + calendar.get(1)); // 1 -> 年
        System.out.println("calendar.get(2) = " + calendar.get(2)); // 2 -> 月 // 月字段是从0开始的
        System.out.println("calendar.get(5) = " + calendar.get(5)); // 日
        System.out.println("calendar.get(11) = " + calendar.get(11));// 小时
        System.out.println("calendar.get(12) = " + calendar.get(12));//分钟
        System.out.println("calendar.get(13) = " + calendar.get(13));//秒

        System.out.println("calendar.get(1) = " + calendar.get(Calendar.YEAR)); // 1 -> 年
        System.out.println("calendar.get(2) = " + calendar.get(Calendar.MONTH)); // 2 -> 月 // 月字段是从0开始的
        System.out.println("calendar.get(5) = " + calendar.get(Calendar.DATE)); // 日
        System.out.println("calendar.get(10) = " + calendar.get(Calendar.HOUR));   // 小时 -> 12
        System.out.println("calendar.get(11) = " + calendar.get(Calendar.HOUR_OF_DAY));// 小时->24
        System.out.println("calendar.get(12) = " + calendar.get(Calendar.MINUTE));//分钟
        System.out.println("calendar.get(13) = " + calendar.get(Calendar.SECOND));//秒
    }

LocalDateTime

jdk8 新增的 线程安全 的日期类
创建LocalDateTime对象
- 由于LocalDateTime类的构造方法是 private 私有的, 不能直接 new 对象 ,
- 故 调用该类的静态方法 now() 创建对象
- 也可以调用该类的静态方法 of(year , month , day , hour , minute , second) 创建对象

返回指定字段 , 可以通过该对象内设的getXXX()方法去获取指定的字段

now.getYear();
public int getYear() {
        return date.getYear();
    }
now.getMonthValue();
public int getMonthValue() {
        return date.getMonthValue();
    }
now.getDayOfMonth();
public int getDayOfMonth() {
        return date.getDayOfMonth();
    }
now.getHour();
    public int getHour() {
        return time.getHour();
    }
now.getMinute();
    public int getMinute() {
        return time.getMinute();
    }
now.getSecond();
    public int getSecond() {
        return time.getSecond();
    }

转换 :
- 定义格式 dateTimeFormatter , 该类不是public 修饰的, 故需要调用它的静态方法 ofPattern来设置
- 时间 -> string : 设置格式 format( datetimeformatter )返回一个字符串
- 字符串 -> 解析成时间 : 调用prase(s , datetimeformatter ) 方法解析 , 返回一个时间对象

代码如下:

    public static void main(String[] args) {
        // 创建 localdatetime 对象, localdatetime类的构造方法是private,不能直接new对象,需要调用它的静态方法 now()创建对象
        LocalDateTime now = LocalDateTime.now();
        System.out.println("now = " + now);  //now = 2024-04-01T12:40:33.341786800

        // 或者调用静态方法 of(year , month , day , hour , minute , second) 创建对象
        LocalDateTime of = LocalDateTime.of(2021, 6, 7, 8, 30);
        System.out.println("of = " + of);  //of = 2021-06-07T08:30

        // 返回指定字段
        System.out.println("now.getYear() = " + now.getYear());
        System.out.println("now.getMonthValue() = " + now.getMonthValue());
        System.out.println("now.getDayOfMonth() = " + now.getDayOfMonth());
        System.out.println("now.getHour() = " + now.getHour());
        System.out.println("now.getMinute() = " + now.getMinute());
        System.out.println("now.getSecond() = " + now.getSecond());

        // 定义格式 : datetimeformatter , DateTimeFormatter不是 public 修饰的, 故需要调用它的静态方法 ofPattern来设置
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss");
        // 时间 -> string
        // 设置格式 format( datetimeformatter ) , 返回成为一个字符串
        String s = now.format(dtf);
        System.out.println("s = " + s);

        // 字符串 解析成 localdatetime对象
        String text = "2086年04月01日 11:52:15";
        // 调用parse(s ,datetimeformatter )方法解析 , 返回一个时间对象
        LocalDateTime parse = LocalDateTime.parse(text, dtf);
        System.out.println("parse = " + parse);
    }

包装类★★★

目的 : 为了编程方便 , Java为每个基本类型提供了一个包装类
Java是面向对象的程序设计语言给每一个包装类提供了一个基本类型
创建包装类对象
- 其实就是把数 保存到对象的 value 属性中
- 根据对应基本类型数据创建包装类对象
- 除了character字符类型外, 其他包装类都可以根据string字符串创建
- 包装类的构造方法从 jdk9开始标记为 @Deprecated已弃用 -> 故建议通过静态方法创建包装类对象 valueOf( )方法
包装类的常用方法
- xxxValue()方法 => 拆箱操作
  - 使用包装类
  - 包装类底层都有一个 value属性 存储 包装类对象对应的基本数据类型
  - 通过调用包装类对象的 xxxValue方法把包装类对象的value属性值 -> 基本数据类型来实现自动拆箱过程
- static int compare(double d1 , double d2) 比较两个基本类型的大小
  - 前面大 : return 正数
  - 前面小 : return 负数
  - 相等 : return 0
- int compareTo(Double anotherDouble) : 比较两个包装类对象的大小
  - 所有包装类都实现了 Comparable接口 ,
  - 比较两个包装类对象的大小 ==> 其实比较的是两个包装类对象的value属性值的大小 (隐含了自动拆箱的过程)
- static double parseDouble(string s) ; 把字符串解析为基本数据类型
  - character 字符类型不能使用该方法将字符串解析
  - 注意, 字符串要符合相应的基本类型格式 , 否则会报 Java.lang.numberformatException异常
  - parseBoolean(string s) : 要么为true, 其他非true的都为false
    - 底层源码为 “true”.equalsIgnoreCase(s);
- 将基本数据类型转换为字符串 : 通过字符串类中的 String.valueOf(value)方法实现
- 装箱 : 调用包装类中静态的valueOf()方法实现的
  - static Double valueOf(double d) : 根据基本类型创建
  - static Double valueOf(String s) : 根据字符串给你创建 , 不包括Character
- 不同包装类的特有方法
  - Double 中 : static long doubleToLongBits(double value) : 可以把double小数的二进制转换为long整数
  - Integer类中:
    - static string toBinaryString(int i): 把十进制整数转换为二进制
    - static string toHexString(int i) : 把十进制整数转换为十六进制
- 小数是否相等的比较方式
  - 1>. x - y < 0.00000001 就认为x与y相等
  - 2>. 比较小数的二进制位是否完全一样 , 调用Double.doubleToLongBitys(x) 方法返回值与Double.doubleToLongBitys(y) 返回值比较是否相等
  - 3>. Double.compare(x , y) 看返回值是否为0
- 把小数转换为二进制分析流程
自动装箱和拆箱
- Java可以自动装箱 \ 自动拆箱
- 装箱 : 基本数据类型 -> 包装类对象 => valueOf()
- 拆箱: 包装类对象 -> 基本数据类型 => xxxValue()
- -128 ~ 127范围内的整数自动装箱保存在缓存当中, 采用享元模式

类与类之间的关系★★★

两个类中间产生了使用
关系有 : 继承 , 实现 , 关联 , 依赖
使用类图来描述 -> UML图 为统一建模语言
- 在分析,设计阶段, 使用UML图以可视化的形式 描述类或者对象的关系\状态
- 常用的UML图: 用例图 , 类图 , 时序图 , 状态图
- 常用的软件 : Star UML , Rational Rose

ToLongBitys(y) 返回值比较是否相等
* 3>. Double.compare(x , y) 看返回值是否为0

把小数转换为二进制分析流程

[外链图片转存中…(img-JaRbPOfV-1712033162760)]
自动装箱和拆箱
- Java可以自动装箱 \ 自动拆箱
- 装箱 : 基本数据类型 -> 包装类对象 => valueOf()
- 拆箱: 包装类对象 -> 基本数据类型 => xxxValue()
- -128 ~ 127范围内的整数自动装箱保存在缓存当中, 采用享元模式

类与类之间的关系★★★

两个类中间产生了使用
关系有 : 继承 , 实现 , 关联 , 依赖
使用类图来描述 -> UML图 为统一建模语言
- 在分析,设计阶段, 使用UML图以可视化的形式 描述类或者对象的关系\状态
- 常用的UML图: 用例图 , 类图 , 时序图 , 状态图
- 常用的软件 : Star UML , Rational Rose

0401 类与类之间的关系