实用类总结

实体类

枚举

枚举的使用

jdk1.5出现，未出现前一般使用静态常量定义枚举里面的内容

// 定义枚举类型
public enum 枚举类型名 {
    枚举值1, 枚举值2, ... [;]
    [构造]
    [属性]
    [方法]
}
// 使用枚举
Gender.枚举值

可以考虑使用的业务场景：业务值（如：学院状态、课程状态等）是一个有序无穷序列

优势：使用枚举不会出现业务值不在枚举范围内的情况

枚举值的本质

public enum Gender {
	公, 母;
}

反编译后：

// final修饰的类，代表不能被继承
// 继承自 Enum（枚举类型的顶级父类）
public final class Gender extends Enum {

    // 私有的构造
    // p1：枚举值
    // p2：序号
    private Gender(String s, int i){
        super(s, i);
    }

    // 静态常量：两个Gender类型的对象
    // Gender.公
    // Gender.母
    public static final Gender 公;    // 枚举的值编译成了静态常量变量
    public static final Gender 母;
    // Gender类型的数组
    private static final Gender[] ENUM$VALUES;    // 枚举类编译成了一个静态常量数组

    // 静态代码块
    static {
        // 对两个Gender对象进行了实例化
        公 = new Gender("公", 0);
        母 = new Gender("母", 1);
        // 将两个Gender对象存储到Gender数组中
        ENUM$VALUES = (new Gender[] {
            _fld516C, _fld6BCD
        });
    }
    
    // 略....
    public static Gender[] values()
    {
        Gender agender[];
        int i;
        Gender agender1[];
        System.arraycopy(agender = ENUM$VALUES, 0, agender1 = new Gender[i = agender.length], 0, i);
        return agender1;
    }

    public static Gender valueOf(String s)
    {
        return (Gender)Enum.valueOf(demo02/Gender, s);
    }
}

可以看出：

• 枚举类型本质上是一个类，所以它是一个引用数据类型
• 枚举类型无法再继承其他类，因为继承了 Enum 类
• 枚举类型的枚举值实际上就是枚举类型的对象

包装类

基本类型 -> 包装类型

• byte -> Byte
• short -> Short
• int -> Integer
• long -> Long
• float -> Float
• double -> Double
• boolean -> Boolean
• char -> Character

注意：包装类型可以解决的问题（包装类型的出现不是为了替代基本数据类型，而是为了完善基本数据类型）

• 基本类型无法使用方法
• 基本类型作为成员变量时，有默认值
• 基本类型无法赋值为 null

常用方法

• static valueOf(基本类型) : 对应的包装类型 将基本类型转换为对应的包装类型
• static valueOf(String s) : 对应的包装类型 将字符串转换为对应的包装类型
• static toString(基本类型) : String 将基本类型转换为包装类型

• toString() : String 将包装类型转换为字符串

 

知识扩展

在jdk1.5以前，Java中的包装类型和基本类型，转换需要使用相应的 API，例如：构造方法或是 valueOf、xxxValue

在jdk1.5 以后，Java 提供了自动装箱和拆箱。直接赋值，赋值过程就实现了转换

int num1 = 10;
// 自动装箱：基本类型转换为包装类型
Integer num2 = num1;
// 自动拆箱：包装类型转换为基本类型
int num3 = num2;

Java是一个完全面向对象的编程语言吗？（面试题）

不是，因为它有基本数据类型。但是，java定义的包装类型可以完善基本类型。

Math类

常用方法

• random() : double 随机 [0.0, 1.0) 范围的浮点数
• sqrt(double) : double 求平方根
• pow(double, double) : double 幂运算
• abs(int) : int 求绝对值
• floor(double) : double 向下取整
• ceil(double) : double 向上取整
• round(double) : long 四舍五入
• max(double, double) : double 求最大值
• min(double, double) : double 求最小值

Random类

可以用于生成随机数

构造方法

• Random() 默认以时间为种子数生成随机数对象
• Random(long seed) 传入种子数生成随机数对象

常用方法

• nextInt(int) : int 生成 [0, max) 的随机整数
• nextDouble() : double 生成 [0.0, 1.0) 的随机小数（不建议使用，因为这个方法是线程不安全的）

         推荐采用： Random 的子类 ThreadLocalRandom

ThreadLocalRandom current = ThreadLocalRandom.current();
// [1, 4)
int nextInt = current.nextInt(1, 4);
System.out.println(nextInt);

String类

本质上是一个字符数组

public final class String {
    /** The value is used for character storage. */
    private final char[] value;
}

String str = "字符串";
String str = new String("字符串");

String str1 = "abc";
String str2 = "abc";
System.out.println(str1 == str2); // true
System.out.println(str1.equals(str2)); // true

String string1 = new String("abc");
String string2 = new String("abc");
System.out.println(string1 == string2); // false
System.out.println(string1.equals(string2)); // true

常用方法

• equals(Object) : boolean 比较两个字符串的内容是否一致
• equalsIgnoreCase(String anotherString) : boolean 比较两个字符串的内容是否一致（不区分大小写）
• toUpperCase() : String 将字符串转换为大写
• toLowerCase() : String 将字符串转换为小写
• length() : int 获取字符串的长度
• isEmpty() : boolean 判断字符串是否为空字符串
• charAt(int index) : char 在字符串根据下标获取字符
• startsWith(String prefix) : boolean 判断字符串是否以指定前缀开头
• endsWith(String suffix) : boolean 判断字符串是否以指定后缀结尾
• indexOf(String str) : int 获取子字符串在字符串中的位置（从前往后找第1个），如果找不到返回 -1
• lastIndexOf(String str) : int 获取子字符串在字符串中的位置（从后往前找第1个），如果找不到返回 -1
• substring(int beginIndex) : String 从指定下标截取子串（包含 beginIndex，截取到最后）
• substring(int beginIndex, int endIndex) : String 从指定下标截取子串到指定下标结束（包含beginIndex，不包含endIndex）
• concat(String) : String 拼接字符串
• replace(CharSequence target, CharSequence replacement) : String 替换字符串
• contains(CharSequence s) : boolean 判断字符串中是否包含指定字符
• split(String regex) : String[] 将字符串按照指定正则切割为字符串数组
• static join(CharSequence delimiter, CharSequence... elements) : String 根据指定分隔符拼接字符串
• join(CharSequence delimiter, Iterable elements) : String 根据指定分隔符拼接集合中的元素
• trim() : String 去除字符串左右两侧的空格
• toCharArray() : char[] 将字符串转换为字符数组
• format(String format, Object... args) : String 格式化字符串（类似于printf()使用方法类似）

Stringbuffer类

String：字符串是一个不可变的对象，当字符串内容发生变化时，都会产生新的字符串。

StringBuffer（字符串缓冲区）：有效提升字符串拼接等变换的性能（建议采用），可以把它理解为是一种可变的字符串。

构造方法

• StringBuffer() 创建一个空的字符串缓冲区
• StringBuffer(String) 创建一个字符串缓冲区并添加好字符串

常用方法

• append(各种类型) : StringBuffer 向字符串缓冲区追加内容（重载方法）
• toString() : String 将字符串缓冲区中的内容转换为字符串
• insert(int offset, String str) : StringBuffer 向字符串缓冲区的指定位置追加内容，原有的内容会依次后移
• deleteCharAt(int index) : StringBuffer 根据下标删除字符串缓冲区的指定字符
• reverse() : StringBuffer 将字符串缓冲区中的内容反转

注意：

在 StringBuffer 中有大量和 String 相同的方法，例如：substring(int start)、replace、length、charAt.....

StringBuilder 的 API 和 StringBuffer 相像，且性能更佳，但它是线程不安全的类型。

StringJoiner类

推荐使用 StringJoiner 优雅的实现字符串的拼接

底层：拼接字符串采用的StringBuile

构造方法

• StringJoiner(CharSequence delimiter) 只指定分隔符
• StringJoiner(CharSequence delimiter, CharSequence prefix, CharSequence suffix) 指定分隔符、前缀、后缀

常用方法

• add(CharSequence newElement) : StringJoiner 拼接字符串
• toString() : String 将拼接的内容转换为字符串
• merge(StringJoiner) : StringJoiner 拼接两个StringJoiner

时间和日期类

Date类

构造方法

• Date() 以当前系统的时间毫秒值来构建 Date 对象
• Date(long date) 传入时间毫秒值来构建 Date 对象

常用方法

• getTime() : long 获取 Date 对象的时间毫秒值（从 January 1, 1970, 00:00:00 到现在的时间毫秒值）
• setTime() : void 给 Date 对象指定时间毫秒值
• before(Date when) : boolean 判断当前 Date 对象是否在指定 Date 对象之前
• after(Date when) : boolean 判断当前 Date 对象是否在指定 Date 对象之后
• equals(Object obj) : boolean 判断两个 Date 对象是否相同（时间一致）

Calendar类

构造方法

• set(int field, int value) : void 给 Calendar 对象指定具体的时间字段值
  • 年：1，YEAR
  • 月：2，MONTH
  • 日：5，DATE
  • 时：10，HOUR
  • 分：12，MINUTE
  • 秒：13，SECOND
  • 星期：... DAY_OF_WEEK
  • ...
• getTime() : Date 转换为 Date 对象
• add(int field, int amount) : void 给指定的时间字段添加值（可以传入正数或负数）

Java8的时间和日期（instant、LocalDate、LocalTime、LocalDateTime）

• Instant：处理时间戳，类比 Date
  • now() : Instant
  • Date类
    • from(Instant) : Date
    • toInstant() : Instant

• LocalDate：处理年月日信息（日期）
  • now() : LocalDate
  • of(年，月，日) : LocalDate
  • isLeapYear() : boolean 判断是否为闰年

• LocalTime：处理时分秒信息（时间）
  • now() : LocalTime
  • of(时，分，秒) : LocalTime

• LocalDateTime：处理年月日时分秒信息
  • now() : LocalDateTime
  • of(年，月，日，时，分，秒) : LocalDateTime

格式化时间和日期

Java8以前的时间和日期类型的使用

     SimpleDateFormat：java.text

构造方法

• simpleDateFormat（格式化字符串）构建日期格式化对象

// 指定格式化字符串：把时间和日期格式表示出来
// y：年
// M：月
// d：日
// H：小时
// m：分钟
// s：秒

常用方法

• parse(时间和日期字符串) : Date 解析字符串为 Date 对象
• format(Date date) : String 格式化 Date 对象为字符串

Java8的时间和日期类型使用

    DateTimeFromatter：java.text

常用方法

• ofParttern(格式化字符串) : DateTimeFormatter
• format(日期) : String
• 在 Java 8 的时间和日期类型中，都有一个 parse 方法，可以传入一个 DateTimeFormatter 对象，以进行解析字符串为指定时间和日期类型的作用

BigDeimal类

用于精确的运算（浮点数计算）

构造方法

• BigDecimal(String val) 根据一个字符串数值创建对象
• 记得千万不要用 BigDecimal(double val) (会用精度错误)

常用方法

• add(BigDecimal) : BigDecimal 加法
• subtract(BigDecimal) : BigDecimal 减法
• multiply(BigDecimal) : BigDecimal 乘法
• divide(BigDecimal, int, int) : BigDecimal 除法
  • p2：int 代表保留几位小数
  • p3：int 代表规则
    • HALF_UP 四舍五入
    • 向上取整
    • 向下取整

final、finally、finalize区别(面试题)

final：可以用来修饰类、变量、方法。

• 修饰类之后，该类无法被继承
• 修饰变量之后，变量变为常量
  • 基本类型，不允许被再次赋值
  • 引用类型，不允许更改地址值，但允许更改内容
• 修饰方法之后，该方法无法被重写

finally：是用于异常处理中，用于编写无论是否出现异常的情况下，都会执行的代码段。一般在其中编写的都是释放资源之类的代码。

finalize：它是 Object 类中的方法，当 GC 对象后，就会调用该方法，是为了给对应的对象进行一些收尾工作。

Integer(面试题)

// 引用数据类型 == 比较的是地址值
// Integer num1 = 127;
// Integer num2 = 127;
Integer num1 = Integer.valueOf(127);
Integer num2 = Integer.valueOf(127);
System.out.println(num1 == num2); // true

//		Integer num3 = 128;
//		Integer num4 = 128;
Integer num3 = Integer.valueOf(128);
Integer num4 = Integer.valueOf(128);
System.out.println(num3 == num4); // false
System.out.println(num3.equals(num4)); // true

原因：

// 摘抄自 Integer 类源码
public static Integer valueOf(int i) {
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}
//  low == -128  
//  high == 127  

interger创建对象时 会方法区将 -128 ~ 127 在方法区的常量池生成出来，并生成一个数组将数字储存。所以 -128 ~ 127 的包装类型的地址值是相同的。