Java EE 第五篇核心类库（二）常用类库

作者: XaviSong | 来源:发表于2020-11-05 21:13 被阅读0次

要求：熟悉常用类库的使用，整理常用方法。

一、objects类

示例方法：

equals()

public static boolean equals(Object a, Object b)
/**
返回true如果参数相等，彼此false其他。 因此，如果这两个参数是null ， true返回，如果只有一个参数为null ， false返回。 否则，通过使用第一个参数的equals方法确定相等性。 
参数 
a - 一个对象 
b - 要与 a进行比较以获得相等性的对象 
结果 
true如果参数彼此相等，否则为 false 
*/

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

toString()

1、toString(Object o)
/**
返回调用的结果 toString对于非 null参数， "null"为 null的说法。 
参数 
o - 一个物体 
结果 
调用的结果 toString对于非 null参数， "null"为 null的说法 
*/

//源码
public static String toString(Object o) {
        return String.valueOf(o);
    }

public static String valueOf(Object obj) {
        return (obj == null) ? "null" : obj.toString();
    }

2、toString(Object o, String nullDefault)
/**
如果第一个参数不是 null ，则返回在第一个参数上调用 toString的结果，否则返回第二个参数。 
参数 
o - 一个物体 
nullDefault - 如果第一个参数是 null ，则返回的字符串 
结果 
如果它不是 null ，则在第一个参数上调用 toString ，否则调用第二个参数
*/
public static String toString(Object o, String nullDefault) {
        return (o != null) ? o.toString() : nullDefault;
    }

compare()

public static <T> int compare(T a, T b, Comparator<? super T> c)
/**如果参数相同则返回0，否则返回c.compare(a, b) 。 因此，如果两个参数都是null则返回0。 
请注意，如果其中一个参数为null ， NullPointerException可能会或可能不会抛出null ，具体取决于订购策略（如果有）， Comparator选择具有null值。 

参数类型 
T - 要比较的对象的类型 
参数 
a - 一个物体 
b - 要与 a进行比较的对象 
c - 比较前两个参数的 Comparator 
结果 
如果参数相同 c.compare(a, b) 0，否则为 c.compare(a, b) 。
*/
    
//源码
public static <T> int compare(T a, T b, Comparator<? super T> c) {
        return (a == b) ? 0 :  c.compare(a, b);
    }

二、Math类

方法：

abs()

//源码，求参数的绝对值
public static int abs(int a) {
        return (a < 0) ? -a : a;
    }

min()

//源码，返回两个参数中的较小值
public static int min(int a, int b) {
        return (a <= b) ? a : b;
    }

max()

//源码，返回两个参数中的较大值
public static int max(int a, int b) {
        return (a >= b) ? a : b;
    }

round() 四舍五入
floor() 返回小于等于参数的最大整数

ceil() 返回大于等于参数的最小整数

//源码较为复杂，展示使用过程
System.out.println(Math.floor(100.5));
System.out.println(Math.ceil(100.5));
System.out.println(Math.round(100.5));
System.out.println(Math.floor(-3.5));
System.out.println(Math.floor(-3.5));
System.out.println(Math.ceil(-3.5));
System.out.println(Math.round(-3.5));
/**
100.0
101.0
101
-4.0
-4.0
-3.0
-3
*/

三、Arrays

方法：

binarySearch(int[] original, int key)

public static int binarySearch(int[] a, int key)
/**
使用二进制搜索算法在指定的int数组中搜索指定的值。 在进行此调用之前，必须对数组进行排序（如sort(int[])方法）。 如果未排序，则结果未定义。 如果数组包含具有指定值的多个元素，则无法保证找到哪个元素。 
参数 
a - 要搜索的数组 
key - 要搜索的值 
结果 
搜索键的索引，如果它包含在数组中; 否则， (-(insertion point) - 1) 。 插入点定义为键将插入到数组中的点：第一个元素的索引大于键，或者如果数组中的所有元素都小于指定键， a.length 。 请注意，当且仅当找到密钥时，这才能保证返回值> = 0。 
*/
    
//源码
public static int binarySearch(int[] a, int key) {
        return binarySearch0(a, 0, a.length, key);
    }

private static int binarySearch0(int[] a, int fromIndex, int toIndex,
                                     int key) {
        int low = fromIndex;
        int high = toIndex - 1;

        while (low <= high) {
            int mid = (low + high) >>> 1;
            int midVal = a[mid];

            if (midVal < key)
                low = mid + 1;
            else if (midVal > key)
                high = mid - 1;
            else
                return mid; // key found
        }
        return -(low + 1);  // key not found.
    }

sort()

public static void sort(int[] a)
/**将指定的数组按升序排序。 
实施说明：排序算法是Vladimir Yaroslavskiy，Jon Bentley和Joshua Bloch的双枢轴快速算法。 该算法在许多数据集上提供O（n log（n））性能，导致其他快速排序降级为二次性能，并且通常比传统（单枢轴）Quicksort实现更快。 

参数 
a - 要排序的数组 
*/

toString()

public static String toString(int[] a)
/**
返回指定数组内容的字符串表示形式。 字符串表示由数组元素的列表组成，用方括号括起来（ "[]" ）。 相邻元素由字符", " （逗号后跟空格）分隔。 元素将转换为字符串，如String.valueOf(int) 。 返回"null"如果a为null 。 
参数 
a - 要返回其字符串表示形式的数组 
结果 
字符串表示形式 a 
*/

//源码
public static String toString(int[] a) {
        if (a == null)
            return "null";
        int iMax = a.length - 1;
        if (iMax == -1)
            return "[]";

        StringBuilder b = new StringBuilder();
        b.append('[');
        for (int i = 0; ; i++) {
            b.append(a[i]);
            if (i == iMax)
                return b.append(']').toString();
            b.append(", ");
        }
    }

copyOf()

public static int[] copyOf(int[] original, int newLength)//使用零复制指定的数组，截断或填充（如有必要），以使副本具有指定的长度。 对于在原始数组和副本中都有效的所有索引，这两个数组将包含相同的值。 对于在副本中有效但不在原件中有效的任何索引，副本将包含0 。 当且仅当指定的长度大于原始数组的长度时，这些索引才会存在。 
/**参数 
original - 要复制的数组 
newLength - 要返回的副本的长度 
结果 
原始数组的副本，用零截断或填充以获得指定的长度 
异常 
NegativeArraySizeException - 如果 newLength是负数 
NullPointerException - 如果 original为空 
    
//源码
public static int[] copyOf(int[] original, int newLength) {
        int[] copy = new int[newLength];
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
    }

应用：

public static void main(String[] args) {
        int[] arr = {8,1,2,3,4,5,6,7};
        System.out.println(arr.toString());//非Arrays静态方法
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
        System.out.println(Arrays.binarySearch(arr,6));
        arr = Arrays.copyOf(arr,10);
        System.out.println(arr.length);
    }
/**
[I@7c30a502
[1, 2, 3, 4, 5, 6, 7, 8]
5
10
*/

四、BigDecimal

解决double类型数据运算的精度丢失问题

方法：分别对应加减乘除，构造方法接收一个字符串参数表示小数

add()
substract()
multiply()
divide()

应用：

BigDecimal b1 = new BigDecimal("0.1");
BigDecimal b2 = new BigDecimal("0.2");
System.out.println(b1.add(b2));
System.out.println(b1.multiply(b2));
System.out.println(b1.divide(b2));
System.out.println(b1.subtract(b2));

//获取值
b1 = b1.add(b2);
double res = b1.doubleValue();//转为double结果
System.out.println(res);

/**
0.3
0.02
0.5
-0.1
0.3
*/

五、Date

可以表示毫秒，并解释为年月日小时等，由于不适于国际化，故国际化的工作使用Calendar类完成。解释为年月日、格式化解析字符串的功能使用DateFormat类完成，故Date真正使用的场景仅在于获取毫秒值，表示特定的时刻。

方法

getTime()

/**
public long getTime()
返回自此 Date对象表示的1970年1月1日00:00:00 GMT以来的毫秒数。 
结果 
自1970年1月1日00:00:00 GMT以来的毫秒数。
*/

构造方法Date()

//获取当前的时间，返回毫秒值
public Date()分配一个 Date对象并对其进行初始化，使其表示分配的时间，测量 Date到毫秒。

构造方法Date(long date)

/**public Date(long date)分配 Date对象并将其初始化以表示自标准基准时间（称为“纪元”）以来的指定毫秒数，即1970年1月1日00:00:00 GMT。 
参数 
date - 格林威治标准时间1970年1月1日00:00:00之后的毫秒数 
*/

setTime()

/**
public void setTime(long time)
将此 Date对象设置为表示格林威治标准时间1970年1月1日00:00:00之后的 time毫秒的时间点。 
参数 
time - 毫秒数。 
*/

应用：

Date date = new Date();
System.out.println(date);

long time = date.getTime() - (1*60*60*1000);
Date date2 = new Date(time);
System.out.println(date2);

//Wed Oct 07 10:53:13 CST 2020
//Wed Oct 07 09:53:13 CST 2020

六、DateFormat类

对Date进行格式化工作

DateFormat是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化和分析日期或时间。日期/时间格式化子类（例如[SimpleDateFormat](SimpleDateFormat.html) ）允许格式化（即，日期→文本），解析（文本“日期”）和规范化。日期表示为Date`对象或自1970年1月1日00:00:00 GMT以来的毫秒数。

DateFormat提供了许多类方法，用于根据默认或给定的区域设置和多种格式样式获取默认日期/时间格式化程序。格式化风格包括FULL ， LONG ， MEDIUM和SHORT 。在方法描述中提供了更多细节和使用这些样式的示例。

DateFormat可帮助您格式化和解析任何区域设置的日期。您的代码可以完全独立于几个月，一周中的日期，甚至是日历格式的区域设置约定：月球与太阳能。

DateFormat是一个抽象类，不能直接使用，需要使用子类SimpleDateFormat。

应用：

将Date对象转化为指定的字符串

SimpleDateFormat format = new SimpleDateFormat("yyyy年MM月dd日 HH:mm ss");
String text = format.format(new Date());
System.out.println(text);

将字符串转为Date（获得毫秒时间戳，可以进行运算，计算时间差，或换算小时、天数等）

Date date = format.parse("2020年12月12日 12:12 40");
        System.out.println((new Date().getTime() - date.getTime())/1000/60/60/24);
//-66

七、Calendar类

可以对Date对象转换时区，抽象类，但是可以使用getInstance方法来返回子类对象。

//常用方法 set、get、add getTime()
Calendar cl = Calendar.getInstance();//默认获得的是当前日期
int year = cl.get(Calendar.YEAR);
System.out.println(year);
int month = cl.get(Calendar.MONTH);
System.out.println(month + 1);//日历0-11
int day = cl.get(Calendar.DAY_OF_MONTH);
System.out.println(day);

//修改日期
cl.set(Calendar.MONTH,10);
System.out.println(cl.get(Calendar.MONTH) + 1);

//日期加减
cl.add(Calendar.YEAR,1);
cl.add(Calendar.MONTH,3);
cl.add(Calendar.MONTH,-3);

//getTime():获取日历时间表示的Date对象
System.out.println(cl.getTime());

//getActualAcrualMaxium():获取参数字段的最大值
System.out.println(cl.getActualMaximum(Calendar.DAY_OF_WEEK));
System.out.println(cl.getActualMaximum(Calendar.DAY_OF_MONTH));

/**
2020
10
7
11
Sun Nov 07 12:20:27 CST 2021
7
30
*/

八、String类

类内使用数组存放字符串中的各个字符，数组确定长度之后无法改变，所以String是不可变类型。
由于String对象是不可变的，所以可以共享，两次创建相同的字符串，实际上仅在（字符串常量池）堆区分配一块内存，两个变量指向同一个地址。但是通过new方式创建的同内容字符串，地址还是不一样的。区别=和new构造的区别。
字符串常量池之前在方法区，之后JDK1.7之后，被拿到了堆区中，运行时常量池还在方法区，也就是永久代（不会被GC回收，只有关闭JVM才会被回收），永久代移到堆内存中之后，自JDK1.8起，方法区的实现改为元空间。永久代中存储的都是加载一次的，所有定义方法的信息，属于共享区间，供多个线程共享（静态变量、常量、类信息、运行时常量池）。堆内存中也分为新生代、老年代、永久代。
String有final修饰，不能被继承，方法也不能被重写。
大量字符串拼接，多次拼接的场景下，不要使用加号，会导致在内存中出现大量垃圾，由于处于永久代中，不会被GC回收，要使用StringBuffer类和StringBuilder中提供的append方法进行尾部拼接。StringBuffer类是线程安全的和StringBuilder是线程不安全的。

Java EE 第五篇核心类库（二）常用类库

一、objects类

二、Math类

三、Arrays

应用：

四、BigDecimal

应用：

五、Date

应用：

六、DateFormat类

七、Calendar类

八、String类

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

Java EE 第五篇 核心类库（二）常用类库

一、objects类

二、Math类

三、Arrays

应用：

四、BigDecimal

应用：

五、Date

应用：

六、DateFormat类

七、Calendar类

八、String类

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

Java EE 第五篇核心类库（二）常用类库