Java常用类库

public final class Objects {

    public static boolean equals(Object a, Object b) {
        return (a == b) || (a != null && a.equals(b));
    }

    public static boolean deepEquals(Object a, Object b) {
        if (a == b)
            return true;
        else if (a == null || b == null)
            return false;
        else
            return Arrays.deepEquals0(a, b);
    }
}

1. 对数组进行升序排序
Array.sort(Object[] array)

// 从元素下标为from,到下标为to-1的元素进行排序    
Arrays.sort(Object[] array, int from, int to)    

2. 为数组元素填充相同的值    
Arrays.fill(Object[] array,Object object)
// 对数组的部分元素填充一个值,从起始位置到结束位置，取头不取尾
Arrays.fill(Object[] array,int from,int to,Object object)    

3. 返回数组的字符串形式
Arrays.toString(Object[] array)
// 返回多维数组的字符串形式
Arrays.deepToString(Object[][] arrays)

// 随机数例子：
Math.random()                         // [0.0，1.0)之间的随机数
Math.random()*100                     // [0.0，100.0)之间的随机数
Math.random()*98 + 2                  // [2.0，100.0)之间的随机数
(int)(Math.random()*98 + 2)           // [2，100)之间的随机整数

// 产生随机数还可以借助java.util.Random类
Random random = new Random();    // 以当前时间为默认种子, 可以使用 Random(long seed) 以指定的种子值
int num = random.nextInt(100);   // 生成一个随机的int值，该值介于[0,100)的区间
double d = random.nextDouble();  //产生[0,1)范围的随机小数

System.out.println(Math.ceil(1.1));    // 2.0
System.out.println(Math.ceil(-1.1));   // -1.0 向上取整

System.out.println(Math.floor(1.1));   // 1.0
System.out.println(Math.floor(-1.1));  // -2.0 向下取整

System.out.println(Math.rint(-1.4));   // -1.0
System.out.println(Math.rint(-1.5));   // -2.0 （四舍六入五取偶）
System.out.println(Math.rint(-2.5));   // -2.0  

System.out.println(Math.round(1.4f));  // 1  (表示”四舍五入”)
System.out.println(Math.round(-1.5f)); // -1 (-1.5 + 0.5 = -1.0 取整为 -1)
System.out.println(Math.round(-1.51)); // -2 (-1.51 + 0.5 = -1.01 向下取整为 -2)
System.out.println(Math.round(-1.6f)); // -2 (-1.6 + 0.5 = -1.1 向下取整为 -2)

import java.math.BigDecimal;

// 使用字符串初始化，推荐
BigDecimal bd1 = new BigDecimal("123.456");
// 也可以使用静态方法 valueOf
BigDecimal bd = BigDecimal.valueOf(123L);   

// 使用double初始化，注意可能的精度丢失
BigDecimal bd2 = new BigDecimal(123.456);

BigDecimal add(BigDecimal augend)                                     // 加法操作
BigDecimal subtract(BigDecimal subtrahend)                            // 减法操作
BigDecimal multiply(BigDecimal multiplieand)                          // 乘法操作
BigDecimal divide(BigDecimal divisor,int scale,int roundingMode )     // 除法操作

double result = 10.0 / 3.0; // 结果可能是3.3333333333333335，存在无限循环小数的近似问题

BigDecimal bd1 = new BigDecimal("10");
BigDecimal bd2 = new BigDecimal("3");
BigDecimal result = bd1.divide(bd2, 2, BigDecimal.ROUND_HALF_UP);  
// 结果为3.33，且进行了四舍五入

// 限制到两位小数，四舍五入
BigDecimal rounded = bd1.setScale(2, BigDecimal.ROUND_HALF_UP);

// 限制到两位小数，不进行四舍五入，直接截断
BigDecimal truncated = bd1.setScale(2, BigDecimal.ROUND_DOWN);

BigDecimal bd3 = new BigDecimal("123.456");
BigDecimal bd4 = new BigDecimal("123.457");

int compareResult = bd3.compareTo(bd4);
if (compareResult < 0) {
    System.out.println("bd3 小于 bd4");
} else if (compareResult > 0) {
    System.out.println("bd3 大于 bd4");
} else {
    System.out.println("bd3 等于 bd4");
}

import java.math.BigDecimal;

public class BigDecimalDemo {
    public static void main(String[] args) {
        // 创建一个很大的BigDecimal数值
        BigDecimal bigNumber = new BigDecimal("123456789012345678901234567890.1234567890");

        // 使用toString()方法
        String toStringResult = bigNumber.toString();
        // 预期输出（取决于BigDecimal的具体值和环境，可能会是科学记数法）:
        // "1.234567890123456789E+28"
        System.out.println("toString()结果: " + toStringResult);

        // 使用toPlainString()方法
        String toPlainStringResult = bigNumber.toPlainString();
        // 预期输出: "123456789012345678901234567890.1234567890"
        // 不管数值多大，都会以普通十进制形式输出，不会使用科学记数法
        System.out.println("toPlainString()结果: " + toPlainStringResult);
    }
}

System.out.println(new Date());   // Tue Oct 12 20:08:43 CST 2021
System.out.println(new Date(0));  // Thu Jan 01 08:00:00 CST 1970

DateFormat df = DateFormat.getDatelnstance();

DateFormat dateInstance = DateFormat.getDateInstance(DateFormat.FULL, Locale.CHINA);
DateFormat timeInstance = DateFormat.getTimeInstance(DateFormat.FULL, Locale.CHINA);

String date = dateInstance.format(new Date());
String time = timeInstance.format(new Date());

System.out.println(date);  // 2021年10月12日 星期二
System.out.println(time);  // 下午08时42分36秒 CST

// Date对象转换成时间字符串
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 E HH:mm:ss");
System.out.println(sdf.format(new Date()));  // 2021年10月12日 星期二 20:36:58

// 字符串转换成时间Date对象
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
Date date = null;
try {
    date = simpleDateFormat.parse("2021-10-1");
}catch (ParseException e) {
    e.printStackTrace();
} 
System.out.println(date);  // Wed Oct 13 00:00:00 CST 2021

Calendar c = Calendar.getInstance();

Calendar calendar = Calendar.getInstance();   // 如果不设置时间，则默认为当前时间
calendar.setTime(new Date());                 // 将系统当前时间赋值给 Calendar 对象

calendar.getTime();                           // 获取当前时间
int year = calendar.get(Calendar.YEAR);       // 获取当前年份
int month = calendar.get(Calendar.MONTH) + 1; // 获取当前月份（月份从 0 开始，所以加 1）
int day = calendar.get(Calendar.DATE);        // 获取日

int week = calendar.get(Calendar.DAY_OF_WEEK) - 1;    // 获取今天星期几（以星期日为第一天）
int hour = calendar.get(Calendar.HOUR_OF_DAY);        // 获取当前小时数（24 小时制）
int minute = calendar.get(Calendar.MINUTE);           // 获取当前分钟
int second = calendar.get(Calendar.SECOND);           // 获取当前秒数
int millisecond = calendar.get(Calendar.MILLISECOND); // 获取毫秒数

int dayOfMonth = calendar.get(Calendar.DAY_OF_MONTH);                 // 获取今天是本月第几天
int dayOfWeekInMonth = calendar.get(Calendar.DAY_OF_WEEK_IN_MONTH);   // 获取今天是本月第几周
int many = calendar.get(Calendar.DAY_OF_YEAR);                        // 获取今天是今年第几天

Calendar c = Calendar.getInstance();
c.set(2021, 11, 11);                     // 设置年月日，时分秒将默认采用当前值

// 定时器Timer构造方法:
Timer timer = new Timer();  //其中会调用this("Timer-" + serialNumber());, 即它以Timer+序列号为该定时器的名字
Timer timer = new Timer(String name);         // 以name作为该定时器的名字
Timer timer = new Timer(boolean isDeamon);    // 是否将此定时器作为守护线程执行
Timer timer = new Timer(name, isDeamon);      // 定时器名字, 是否为守护线程

public class TimerDemo {
    public static void main(String[] args) {
        // 创建Timer对象
        final Timer timer = new Timer();

        try {
            // 任务执行时间
            final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            Date date = sdf.parse("2022-02-24 13:45:30");

            // 创建定时任务
            timer.schedule(new Task(), date);
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }

    private static class Task extends TimerTask{
        @Override
        public void run() {
            System.out.println("Boom!"); // 炸弹爆炸
        }
    }
}

schedule(TimerTask task, Date time) // 设定某个时间执行任务（只执行一次）
schedule(TimerTask task, long delay) // 安排在指定延迟后执行指定的任务(毫秒)

// 第一次在指定firstTime时间点执行任务，之后每隔period时间调用任务一次
schedule(TimerTask task,Date firstTime,long period) 

// delay时间后开始执行任务，并每隔period时间调用任务一次
schedule(TimerTask task,long delay,long period) 

scheduleAtFixedRate(TimerTask task,Date firstTime,long period) // 指定的时间开始进行重复的固定速率执行．

scheduleAtFixedRate(TimerTask task,long delay,long period)  // 指定的延迟后开始进行重复的固定速率执行．


public boolean cancel()    // 取消定时器