API篇（Java - 工具类（Tool））（doing）

wclass-zhengge

已于 2024-08-15 23:25:39 修改

阅读量437

点赞数 12

文章标签： java 数据库算法

于 2024-08-15 23:23:14 首次发布

本文链接：https://blog.csdn.net/qq_51226710/article/details/141234013

版权

2.2. toString() & deepToString()

2.2.1. 简介

2.2.2. 源码

2.2.3. 示例

2.3. sort() & parallelSort()

2.5. compare() & compareUnsigned()

2.5.1. 简介

2.5.2. 源码

2.5.3. 示例

2.6. copyOf() & copyOfRange()

2.8.4. 比较 equals() & deepEquals() 方法

2.11. parallelPrefix()

2.11.1. 简介

2.11.2. 源码

2.11.3. 示例

2.12. setAll() & parallelSetAll()

2.10 indexOfSubList() & lastIndexOfSubList()

2.11 unmodifiableXxx()

四、对象工具类（Objects）

1. Objects & Object 区别

5.6. toString(Object o, String nullDefault)

5.7. compare

5.8. requireNonNull(T obj)

5.9. requireNonNull(T obj, String message)

5.10. isNull

5.11. nonNull

6. 参考文献

前言

工具类定义的都是一些静态方法,每个方法都是以完成一个共用的功能为目的，

它的好处就是内部都是一些静态方法, 每个方法完成一个功能，一次编写, 处处可用, 提高代码的重用性，

一般建议工具类的构造器都私有化处理，因为工具类不需要创建对象！

一、数学工具类（Math）

Java开发时会遇到许多要计算的功能，Math作为一个基础的处理数据的工具类，也尤为常见，

Math类有private的构造函数，所以无法创建Math类的对象；

Math类中的所有方法都是static（静态）方法，所以可以直接通过类名来调用它们。

例如：

double p = Math.PI;
double a = Math.abs(-0.99237);

虽然Math类的使用非常简单，但是里面的方法还是需要详细了解后才能做到如臂使指，

下面就是本文的主题，Math类的详解，一起来回忆回忆吧。

参考链接：Java工具类------Math类的详解及使用_math.pi函数-CSDN博客

1. 常量

    /**
     * The {@code double} value that is closer than any other to
     * <i>e</i>, the base of the natural logarithms.
     */
    public static final double E = 2.7182818284590452354;

    /**
     * The {@code double} value that is closer than any other to
     * <i>pi</i>, the ratio of the circumference of a circle to its
     * diameter.
     */
    public static final double PI = 3.14159265358979323846;

double p = Math.PI;
double a = Math.abs(-0.99237);

2. 常用方法

2.1. 获取随机数字

功能	描述
random()	生成大于等于 0.0 且小于 1.0 的double型随机数

示例

    public static void main(String[] args) {
        //生成一个0.0到1.0的随机数
        double a = Math.random();
        //生成一个0-100的随机数
        int b = (int) (Math.random()*100);
        //输出所有值
        System.out.println(a);
        System.out.println(b);
    }

2.2. 三角函数运算

功能	描述
sin(radians)	返回以弧度为单位的角度的三角正弦函数值
cos(radians)	返回以弧度为单位的角度的三角余弦函数值
tan(radians)	返回以弧度为单位的角度的三角正切函数值
toRadians(degreee)	将以度为单位的角度值转换为以弧度表示
toDegrees(radians)	将以弧度为单位的角度值转换为以度表示
asin(a)	返回以弧度为单位的角度的反三角正弦函数值
acos(a)	返回以弧度为单位的角度的三角f反余弦函数值
atan(a)	返回以弧度为单位的角度的三角反正切函数值

示例

  public static void main(String[] args) {
        //获取90度的正弦值
        double a = Math.sin(Math.PI/(180/90)) ;
        //获取0的余弦值
        double b =  Math.cos(0);
        //获取0的正切值
        double c = Math.tan(0) ;
        //获取-1的反正弦值
        double d = Math.asin(-1);
        //获取-1的反余弦值
        double e = Math.acos(-1) ;
        //获取90的反正切值
        double f = Math.atan(90) ;
        //将90,30的笛卡尔坐标转换为极坐标，并返回极坐标的角度值
        double g = Math.atan2(90,30) ;

        System.out.println("90度的正弦值:   "+a);
        System.out.println("0的余弦值:     "+b);
        System.out.println("1的正切值:     "+c);
        System.out.println("-1的反正弦值:   "+d);
        System.out.println("-1的反余弦值:   "+e);
        System.out.println("90的反正切值:   "+f);
        System.out.println("90,30的笛卡尔坐标转换为极坐标，并返回极坐标的角度值:   "+g);
    }

2.3. 指数运算

功能	描述
pow(a，b)	生成a的b次方
Math.sqrt(a)	对于 x >= 0的数字，返回 x 的平方根
cbrt(a)	生成a的立方根
Math.exp(a)	返回 e 的 a 次幂
Math.log(a)	返回 a 的对数，即 ln a 的值
Math.log10(a)	返回以 10 为底 a 的对数
Math.log1p(a)	返回a和1之和的对数

示例

    public static void main(String[] args) {
        //生成10的1次方
        double a = Math.pow(10,1);
        //生成10的3次方
        double b = Math.pow(10,3);
        //生成10的0.2次方
        double c = Math.pow(10,0.2);
        //生成10的-7次方
        double d = Math.pow(10,-7);
        //输出所有值
        System.out.println("10的1次方" + a);
        System.out.println("10的3次方" + b);
        System.out.println("10的0.2次方" + c);
        System.out.println("10的-7次方" + d);
    }

     public static void main(String[] args) {
        //获取4的平方值
        double a =  Math.sqrt(4.0);
        //获取8的立方值
        double b =  Math.cbrt(8.0);
        //获取-8的立方值
        double c =  Math.cbrt(-8.0);

        System.out.println("获取4的平方值    " + a);
        System.out.println("获取8的立方值    " + b);
        System.out.println("获取-8的立方值    " + c);
    }

    public static void main(String[] args) {
        //获取e的5次幂
        double a = Math.exp(5.0) ;
        System.out.println("e的5次幂:   "+a);
    }

    public static void main(String[] args) {
        //获取5.0的对数
        double a = Math.log(5.0) ;
        //获取以10为底5.0的对数
        double b = Math.log10(5.0) ;
        //获取以5+1的对数
        double c = Math.log1p(5.0) ;
        System.out.println("5.0的对数:   "+a);
        System.out.println("以10为底5.0的对数:   "+b);
        System.out.println("以5+1的对数:   "+c);
    }

2.4. 求整运算

功能	描述
ceil(x)	x 向上取整为它最接近的整数。该整数作为一个双精度值返回
floor(x)	x 向下取整为它最接近的整数。该整数作为一个双精度值返回
rint(x)	x 取整为它最接近的整数。如果 x 与两个整数的距离相等，偶数的整数作为一个双精度值返回
round(x)	如果 x 是单精度数，返回（int）Math.floor(x+0.5)；如果 x 是双精度数，返回（long）Math.floor(x+0.5)

示例

    public static void main(String[] args) {
        //向上取整
        double a = Math.ceil(0.1);
        //向下取整
        double b = Math.floor(-1.09);
        //输出所有值
        System.out.println("向上取整    " + a);
        System.out.println("向下取整    " + b);
    }

    public static void main(String[] args) {
        //获取小数-5.5最近的整数，若有两个结果则取偶数
        double a =  Math.rint(-5.5);
        //获取小数5.5最近的整数，若有两个结果则取偶数
        double b =  Math.rint(5.5);

        System.out.println("小数-5.5最近的整数    " + a);
        System.out.println("小数5.5最近的整数  " + b);
    }

    public static void main(String[] args) {
        //参数为double类型，返回结果为long
        long a =  Math.round(5.49);
        //参数为float类型，返回结果为int
        int b = Math.round(1.51f);
        //输出四舍五入后的值
        System.out.println("5.49四舍五入    " + a);
        System.out.println("1.51f四舍五入   " + b);
    }

2.5. 数字处理

功能	描述
min、max	min、max方法用于返回两个数（int、long、float 或 double型）的最小值和最大值
abs	abs方法用于返回一个数（int、long、 float 或 double 型）的绝对值

示例

    public static void main(String[] args) {
        //10和20那个大
        int a = Math.max(10, 20);
        //-1和-5那个小
        int b = Math.min(-1, -5);
        //输出所有值
        System.out.println("10和20那个大:     " + a);
        System.out.println("-1和-5那个小:     " + b);
    }

    public static void main(String[] args) {
        double a = -1.1;
        float b = -1;
        long c = -1111111;
        int d = -1;
        //输出所有值为正数
        System.out.println(Math.abs(a));
        System.out.println(Math.abs(b));
        System.out.println(Math.abs(c));
        System.out.println(Math.abs(d));
    }

二、数组工具类（Arrays）

1. 常量

2. 常用方法

功能	描述
asList()	返回由指定数组支持的固定大小的列表。
sort()	将数组排序（升序）
parallelSort()	将指定的数组按升序排序
binarySearch()	使用二分搜索法快速查找指定的值（前提是数组必须是有序的）
compare()	按字典顺序比较两个数组
compareUnsigned()	按字典顺序比较两个数组，将数字元素处理为无符号
copyOf()	填充复制数组
copyOfRange()	将数组的指定范围复制到新数组
equals()	比较两个数组
deepEquals()	比较两个数组深度
toString()	将数组转换为字符串
deepToString()	将一个多维数组转换为字符串
fill()	将指定元素填充给数组每一个元素
mismatch()	查找并返回两个数组之间第一个不匹配的索引，如果未找到则返回-1
parallelPrefix()	使用提供的函数对数组元素进行操作
parallelSetAll()	使用提供的生成器函数并行设置指定数组的所有元素以计算每个元素
setAll()	使用提供的生成器函数设置指定数组的所有元素以计算每个元素

2.1. asList()

2.1.1. 简介

功能：返回由指定数组支持的固定大小的列表

参数：asList(T… a)

返回值：一个列表

2.1.2. 源码

2.1.3. 示例

    @Test
    public void asListTest() {
        List<String> ss = Arrays.asList("hello", "world");
//        List<String> ss1 = Arrays.asList("hello", "world",1);   报错，类型必须一直（泛型）
        System.out.println(ss);  //[hello, world]
        
//        ss.add("java");  //UnsupportedOperationException  会报错
//        ss.remove(1);   //UnsupportedOperationException  会报错
        
        System.out.println(ss.get(0));  //hello
        ss.set(0, "java");
        System.out.println(ss);  //[java, world]

    }

注意：将这一数组转换为列表后，对应的列表是不支持添加和删除操作的，否则会报错，但可以修改和获取元

素。

2.2. toString() & deepToString()

2.2.1. 简介

功能：将数组转换为字符串

参数：待转化数组

返回值：转化后的字符串

2.2.2. 源码

2.2.3. 示例

    @Test
    public void toStringTest() {
        String[] str = {"java", "hello", "javascript"};
        String[][] strs = {{"a", "b"}, {"c"}, {"d", "e"}};
        System.out.println(Arrays.toString(str));
        //[java, hello, javascript]
        
        System.out.println(Arrays.toString(strs));
        //[[Ljava.lang.String;@4563e9ab, [Ljava.lang.String;@11531931, [Ljava.lang.String;@5e025e70]
        //普通的toString()方法只转化一层，内层还是地址值

        System.out.println(Arrays.deepToString(strs));
        //可以深度转换
        //[[a, b], [c], [d, e]]
    }

2.3. sort() & parallelSort()

2.3.1. 简介

功能：都是将数组排序（默认升序，支持lambda，泛型）

参数：

sort(Object[] a[, int fromIndex, int toIndex])
或者sort(T[] a[, int fromIndex, int toIndex,] Comparator<? super T> c)
parallelSort(Object[] a[, int fromIndex, int toIndex])
或者parallelSort(T[] a[, int fromIndex, int toIndex,] Comparator<?
super T> c)

返回值：无

2.3.2. 源码

2.3.3. 示例

    @Test
    public void sortTest() {
        String[] str = {"abc", "add", "java", "hello", "javascript"};
        int[] ii = {1, 8, 99, 222, 35};

        System.out.println(Arrays.toString(str));
        System.out.println(Arrays.toString(ii));

        //单参数情况
        //Arrays.sort(str);  默认全排，字母会按照字母表顺序
        //Arrays.sort(ii);
        //System.out.println(Arrays.toString(str));  //[abc, add, hello, java, javascript]
        //System.out.println(Arrays.toString(ii));  //[1, 8, 35, 99, 222]

        //多参数情况
        //Arrays.sort(str,2,4);   只排列指定范围内的
        //Arrays.sort(ii,2,4);
        //System.out.println(Arrays.toString(str));  //[abc, add, hello, java, javascript]
        //System.out.println(Arrays.toString(ii));  //[1, 8, 99, 222, 35]

        //可传入lambda表达式(多参数情况可指定开始结束位置)
//        Arrays.sort(str, (a, b) -> b.compareTo(a));  //降序
//        System.out.println(Arrays.toString(str));  //[javascript, java, hello, add, abc]


        //parallelSort()方法目前我实验感觉与sort()相差无几，基本相似
        Arrays.parallelSort(str);
        System.out.println(Arrays.toString(str));  //[abc, add, hello, java, javascript]

        Arrays.parallelSort(str,(a,b)->b.compareTo(a));
        System.out.println(Arrays.toString(str));  //[javascript, java, hello, add, abc]
    }

2.4. binarySearch()

2.4.1. 简介

功能：使用二分搜索法快速查找指定的值（前提是数组必须是有序的，支持lambda表达式，泛型）

参数：binarySearch(Object[] a[, int fromIndex, int toIndex], Object key)

返回值：有则返回对应下标，无则返回负值

2.4.2. 源码

2.4.3. 示例

    @Test
    public void binarySearchTest() {
        int[] a = {1, 5, 7, 4, 6, 7, 8, 4, 9, 0};
        Arrays.sort(a);  //必须先排序
        System.out.println(Arrays.toString(a));
        //[0, 1, 4, 4, 5, 6, 7, 7, 8, 9]
        System.out.println(Arrays.binarySearch(a, 4));  //2
        System.out.println(Arrays.binarySearch(a, 11));  //-11
        //也可指定范围查找,其查找机制是折半查找，每次缩小一半范围
    }

2.5. compare() & compareUnsigned()

2.5.1. 简介

功能：按字典顺序比较两个数组

参数：

compare(T[] a, 【int aFromIndex, int aToIndex】, T[] b,【 int bFromIndex, int bToIndex】,【 Comparator<? super T> cmp】)

返回值：

如果第一个和第二个数组相等并且包含相同顺序的相同元素，则值为0 ;
如果第一个数组按字典顺序小于第二个数组，则值小于0 ;
如果第一个数组按字典顺序大于第二个数组，则值大于0

2.5.2. 源码

2.5.3. 示例

    @Test
    public void compareTest() {
        int[] a = {1, 2, 3, 4};
        int[] b = {1, 2, 3, 4, 5};
        int[] c = {1, 2, 3, 4, 5};
        String[] s1 = {"java","hello","c++"};
        String[] s2 = {"java","hello"};

//        System.out.println(Arrays.compare(a,b));  //-1
//        System.out.println(Arrays.compare(b,a));  //1
//        System.out.println(Arrays.compare(b,c));  //0

        System.out.println(Arrays.compare(s1,s2));  //1
        //也可划定范围去比较，或者传入lambda



//        System.out.println(Arrays.compareUnsigned(s1,s2));//报错
        System.out.println(Arrays.compareUnsigned(a,b));  //-1
    }

注意：compareUnsigned()只能比较byte(),short(),int(),long()数字型数组，可以划定比较范围，但不支持

lambda。

2.6. copyOf() & copyOfRange()

2.6.1. 简介

功能：复制填充数组

参数：

copyOf(int[] original, int newLength)…
copyOf(T[] original, int newLength)
copyOfRange(int[] original, int from, int to）…
copyOfRange(T[] original, int from, int to)
copyOfRange(U[] original, int from, int to, 类<? extends T[]> newType)

返回值：复制填充后的数组

2.6.2. 源码

2.6.3. 示例

    @Test
    public void copyOfTest() {

        //copyOf

        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};
        int[] arr1 = Arrays.copyOf(arr, 5);  //拷贝长度为5，第二个参数为新数组的长度
        int[] arr2 = Arrays.copyOf(arr, 15);
        System.out.println(Arrays.toString(arr1));  //[1, 2, 3, 4, 5]
        System.out.println(Arrays.toString(arr2));  //[1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 0, 0, 0]

        arr[0] = 20;   //改变原数组
        System.out.println(Arrays.toString(arr));     //原数组改变
        System.out.println(Arrays.toString(arr1));   //复制后的数组不变

        String[] str = {"java","hello","world"};
        String[] str1 = Arrays.copyOf(str,2);
        String[] str2 = Arrays.copyOf(str,5);
        System.out.println(Arrays.toString(str1));  //[java, hello]
        System.out.println(Arrays.toString(str2));  //[java, hello, world, null, null]




        //copyOfRange()

        int[] arrs = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};
        int[] arr3 = Arrays.copyOfRange(arrs,2,8);   //[3, 4, 5, 6, 7, 8]
        int[] arr4 = Arrays.copyOfRange(arrs,5,15);  //[6, 7, 8, 9, 0, 0, 0, 0, 0, 0]
        System.out.println(Arrays.toString(arr3));
        System.out.println(Arrays.toString(arr4));
        arrs[6] = 99;  //改变原数组
        System.out.println(Arrays.toString(arrs));   //[1, 2, 3, 4, 5, 6, 99, 8, 9, 0]  原数组改变
        System.out.println(Arrays.toString(arr3));   //[3, 4, 5, 6, 7, 8]  复制后的不会随着改变

    }

2.6.4. 注意

copyOf()是从原数组0位置开始拷贝指定长度到新数组

copyOfRange()是从原数组中指定范围拷贝到新数组

如果指定长度或者范围超出原数组范围，则超出部分会补上此数据类型的默认值，如String类型会补null，int型会

补0

2.7. equals()

2.7.1. 简介

功能：比较两个数组

参数：

equals(int[] a,【 int aFromIndex, int aToIndex】, int[] b,【 int bFromIndex, int bToIndex】)…
equals(T[] a, 【int aFromIndex, int aToIndex】, T[] b,【 int bFromIndex, int bToIndex】, Comparator<? super T> cmp)

返回值：boolean

2.7.2. 源码

2.7.3. 示例

@Test
    public void equalsTest() {
        int[] a = {1, 2, 3, 4, 5, 6};
        int[] b = {6, 5, 3, 4, 2, 1};

        System.out.println(Arrays.equals(a, b));   //false
        System.out.println(Arrays.equals(a, 2, 3, b, 2, 3));  //指定比较范围  true
    }

2.8. deepEquals()

2.8.1. 简介

功能：比较两个数组的深度

参数：deepEquals(Object[] a1, Object[] a2)

返回值：boolean

2.8.2. 源码

2.8.3. 示例

    @Test
    public void deepEqualsTest() {
        String[] s1 = {"java", "hello", "c++"};
        String[] s2 = {"java", "hello"};
        String[] s3 = {"java", "hello", "c++"};
        System.out.println(Arrays.deepEquals(s1, s2));  //false
        System.out.println(Arrays.deepEquals(s1, s3));  //true

        String[][] s4 = {{"hello"}, {"java"}, {"c++"}, {"python"}};
        String[][] s5 = {{"hello"}, {"java"}, {"c++"}, {"python"}};
        System.out.println(Arrays.deepEquals(s4, s5));  //true
        System.out.println(Arrays.equals(s4, s5));    //false
        
        int[] a = {1,2};
        int[] b = {1,2};
//        System.out.println(Arrays.deepEquals(a,b));  //报错
        
    }

2.8.4. 比较 equals() & deepEquals() 方法

相同点

两者都是比较数组是否相等的方法

不同点

equals默认从头比较到尾，也可以指定范围，但是deepEquals不能指定范围
deepEquals可以比较多维数组，equals不能
deepEquals不支持比较基本类型数组，equals支持

2.9. fill()

2.9.1. 简介

功能：将指定元素填充给数组每一个元素

参数：fill(int[] a, 【int fromIndex, int toIndex】, int val)

返回值：无

2.9.2. 源码

2.9.3. 示例

    @Test
    public void fillTest() {
        String[] a = {"a", "b", "c", "d", "e", "f"};
        System.out.println(Arrays.toString(a));  //[a, b, c, d, e, f]
        Arrays.fill(a, "java");
        System.out.println(Arrays.toString(a));  //[java, java, java, java, java, java]

        String[] b = {"a", "b", "c", "d", "e", "f"};
        System.out.println(Arrays.toString(b));  //[a, b, c, d, e, f]
        Arrays.fill(b, 2, 5, "java");
        System.out.println(Arrays.toString(b));  //[a, b, java, java, java, f]
        
        //默认全填充，也可以指定范围，会改变原数组
    }

2.10. mismatch()

2.10.1. 简介

功能：查找并返回两个数组之间第一个不匹配的索引，如果未找到则返回-1

参数：

mismatch(int[] a, 【int aFromIndex, int aToIndex】, int[] b,【 int bFromIndex, int bToIndex】)
mismatch(T[] a, 【int aFromIndex, int aToIndex】, T[] b,【 int bFromIndex, int bToIndex】, Comparator<? super T> cmp)

返回值：两个数组之间第一个不匹配的索引，未找到不匹配则返回-1。

2.10.2. 源码

2.10.3. 示例

    @Test
    public void mismatchTest() {
        String[] s1 = {"java", "c++", "html", "css", "Javascript", "world"};
        String[] s2 = {"world", "c++", "html", "css", "Javascript"};
        System.out.println(Arrays.mismatch(s1, s2)); //0
        System.out.println(Arrays.mismatch(s1, 1, 4, s2, 1, 4));  //-1
        System.out.println(Arrays.mismatch(s1, 1, 5, s2, 1, 4));  //3

    }

2.11. parallelPrefix()

2.11.1. 简介

功能：使用提供的函数并行地累积给定数组的每个元素。

参数：

parallelPrefix(int[] array, 【int fromIndex, int toIndex】, IntBinaryOperator op)
parallelPrefix(T[] array, 【int fromIndex, int toIndex】, BinaryOperator op)

返回值：无

2.11.2. 源码

2.11.3. 示例

 	@Test
    public void parallelPrefixTest() {
        String[] s1 = {"java", "c++", "html", "css", "Javascript", "world"};
        System.out.println(Arrays.toString(s1));   //[java, c++, html, css, Javascript, world]
        Arrays.parallelPrefix(s1, String::concat);
        System.out.println(Arrays.toString(s1));   //[java, javac++, javac++html, javac++htmlcss, javac++htmlcssJavascript, javac++htmlcssJavascriptworld]

        int[] a = {1, 2, 3, 4, 5};
        System.out.println(Arrays.toString(a));  //[1, 2, 3, 4, 5]
        Arrays.parallelPrefix(a, (x, y) -> x * y);
        System.out.println(Arrays.toString(a));  //[1, 2, 6, 24, 120]
        Arrays.parallelPrefix(a, 2, 4, (x, y) -> x / y);
        System.out.println(Arrays.toString(a));  //[1, 2, 6, 0, 120]  也可指定范围
    }

2.12. setAll() & parallelSetAll()

2.12.1. 简介

功能：使用提供的生成器函数设置指定数组的所有元素以计算每个元素。

参数：

parallelSetAll(T[] array, IntFunction<? extends T> generator)
setAll(T[] array, IntFunction<? extends T> generator)

返回值：无

2.12.2. 源码

2.12.3. 示例

    @Test
    public void setAllTest() {
        int[] arr = {111, 222, 333, 444, 555};
        Arrays.setAll(arr, (e) -> e + 5);
        System.out.println(Arrays.toString(arr));   //[5, 6, 7, 8, 9]

        String[] str = {"a", "b", "c"};
        Arrays.setAll(str, new IntFunction<>() {
            @Override
            public String apply(int value) {
                return value + "java";
            }
        });
        System.out.println(Arrays.toString(str));  //[0java, 1java, 2java]

        int[] arr1 = {111, 222, 333, 444, 555};
        Arrays.parallelSetAll(arr1, new IntUnaryOperator() {
            @Override
            public int applyAsInt(int operand) {
                return operand + 5;
            }
        });
        System.out.println(Arrays.toString(arr1));   //[5, 6, 7, 8, 9]

        String[] str1 = {"a", "b", "c"};
        Arrays.parallelSetAll(str1, (m) -> m + "haha");
        System.out.println(Arrays.toString(str1));  //[0haha, 1haha, 2haha]


        //总结setAll和parallelSetAll差不多，且都支持lambda
        //通过索引值去改变元素，改编后的值与索引有关
    }

2.12.4. 总结

本文大致包含了所有的方法，除了 Java 11 之后新增的，或者我看漏的，文中如有错误，还请指出，大家一起进

步！

3. 参考文献

Java中Arrays数组工具类的使用全解_arrays.setall-CSDN博客

三、集合工具类（Collections）

1. 简介

Collections则是集合类的一个工具类/帮助类，其中提供了一系列静态方法，

用于对集合中元素进行排序、搜索以及线程安全等各种操作。

2. 常用方法

2.1. reverse()

public static void main(String[] args) {
    List list = new ArrayList();
    list.add(1);
    list.add(2);
    list.add(3);
    list.add(4);

    System.out.println(list);
    System.out.println("----反转后----");
    
    Collections.reverse(list);
    System.out.println(list);

}

2.2. sort()

根据元素的自然顺序对指定列表按升序进行排序。

示例

public static void main(String[] args) {
    List list = new ArrayList();
    list.add(1);
    list.add(4);
    list.add(2);
    list.add(3);

    System.out.println(list);
    System.out.println("----排序后----");

    Collections.sort(list);
    System.out.println(list);

}

2.3. swap()

示例

public static void main(String[] args) {
    List list = new ArrayList();
    list.add(1);
    list.add(4);
    list.add(2);
    list.add(3);

    System.out.println(list);
    System.out.println("----交换后----");

    Collections.swap(list,1,2);
    System.out.println(list);

}

2.4. min() & max()

示例

public static void main(String[] args) {
     List list = new ArrayList();
     list.add(1);
     list.add(4);
     list.add(2);
     list.add(3);

     System.out.println(Collections.min(list));
     System.out.println(Collections.max(list));

 }

2.5 copy()

目标集合大小必须大于等于原集合大小

示例

public static void main(String[] args) {
     List list = new ArrayList();
     list.add(1);
     list.add(4);
     list.add(2);
     list.add(3);

     ArrayList arrayList = new ArrayList();
     arrayList.add("");
     arrayList.add("");
     arrayList.add("");
     arrayList.add("");
     arrayList.add("");

     Collections.copy(arrayList,list);
     System.out.println(arrayList);

 }

2.6 fill()

示例

public static void main(String[] args) {
     List list = new ArrayList();
     list.add(1);
     list.add(4);
     list.add(2);
     list.add(3);

     Collections.fill(list,"皮皮虾");
     System.out.println(list);

 }

2.7 replaceAll()

替换批定元素为某元素,若要替换的值存在刚返回true,反之返回false

示例

public static void main(String[] args) {
     List list = new ArrayList();
     list.add(1);
     list.add(4);
     list.add(2);
     list.add(3);

     boolean b = Collections.replaceAll(list, 2, "皮皮虾");
     System.out.println(b);
     System.out.println(list);

 }

2.8 shuffle()

示例

public static void main(String[] args) {
     List list = new ArrayList();
     list.add(1);
     list.add(4);
     list.add(2);
     list.add(3);

     Collections.shuffle(list);
     System.out.println(list);

     Collections.shuffle(list);
     System.out.println(list);

     Collections.shuffle(list);
     System.out.println(list);

 }

2.9 rotate()

集合中的元素向后移m个位置，在后面被遮盖的元素循环到前面来 (负数向左移动，正数向右移动)

示例

public static void main(String[] args) {
    List list = new ArrayList();
    list.add(1);
    list.add(4);
    list.add(2);
    list.add(3);

    System.out.println(list);
    System.out.println("正向移动后");
    Collections.rotate(list,2);
    System.out.println(list);

    System.out.println("负向移动后");
    Collections.rotate(list,-1);
    System.out.println(list);
}

2.10 indexOfSubList() & lastIndexOfSubList()

示例

public static void main(String[] args) {
    List list = new ArrayList();
    list.add(1);
    list.add(4);
    list.add(3);
    list.add(2);
    list.add(3);

    ArrayList arrayList = new ArrayList();
    arrayList.add(3);

    int i = Collections.indexOfSubList(list, arrayList);
    System.out.println(i);

    int num = Collections.lastIndexOfSubList(list, arrayList);
    System.out.println(num);
}

2.11 unmodifiableXxx()

返回指定集合对象的不可变视图

示例

public static void main(String[] args) {
    List list = new ArrayList();
    list.add(1);
    list.add(4);
    list.add(2);
    list.add(3);

    try {
        Collection collection = Collections.unmodifiableCollection(list);
        collection.add(6);
        System.out.println(list);
    }catch (Exception e) {
        System.out.println("出现错误");
    }

}

四、对象工具类（Objects）

1. Objects & Object 区别

Object 是 Java 中所有类的基类，位于java.lang包。
Objects 是 Object 的工具类，位于java.util包。

java.util.Objects由 Java 7 引入的，包含static实用程序方法，用于操作对象或在操作前检查某些条件。

需要注意的是：这个类用关键字final修饰不能被继承，拥有私有的构造函数。

2. 问题描述

用户希望使用静态工具方法实现非空验证、比较等操作。

3. 适用场景

它在流处理中相当有用，实用程序包括null或null方法，用于计算对象的哈希代码，

返回对象的字符串，比较两个对象，以及检查索引或子范围值是否超出范围。

4. 构造函数

    private Objects() {
        throw new AssertionError("No java.util.Objects instances for you!");
    }

可以看到Objects类中只有一个构造函数，并且声明为private，构造函数中抛出一个AssertionError。因此这个类

不可以实例化。

5. 常用方法

5.1. equals

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

这里Objects.equals方法中已经做了非空判断，所以不会抛出空指针异常，它是null-save空指针安全的。

如果两个参数相等，返回true，否则返回false。

因此，如果这两个参数是null，返回true，如果只有一个参数为null，返回false，

否则，通过使用第一个参数的equals方法确定相等性。

5.2. deepEquals

    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);
    }

若两个都是null值的字符串或者数组比较，返回true如果两个参数都是数组，则使用Arrays.deepEquals中的算法

来确定相等性，在参数数组的循环中，递归调用deepEquals0，直到出现不相同的元素，或者循环结束；

否则，通过使用第一个参数的equals方法确定相等性。

注：该方法在数组比较中尤其有用，当我们在业务中需要判断两个复杂类型，

比如使用了泛型的列表对象List、或者通过反射得到的对象，不清楚对象的具体类型时可以直接使用此方法来解

决。

测试：

public static void main(String[] args) {
        String[] arr1 = new String[]{"123"};
        String[] arr2 = new String[]{"124"};
        int[] arr3 = new int[]{1,2,3};
        int[] arr4 = new int[]{1,2,3};
        String s1 = "100";
        int s2 = 100;
        boolean b1 = Objects.deepEquals(arr1,arr2);
        boolean b2 = Objects.deepEquals(arr3,arr4);
        boolean b3 = Objects.deepEquals(s1,s2);
        System.out.println("字符串数组比较结果："+b1);
        System.out.println("整型数组比较结果："+b2);
        System.out.println("字符串和整型比较结果："+b3);
    }

结果为：

Arrays.deepEquals0方法的源代码如下：

static boolean deepEquals0(Object e1, Object e2) {
        assert e1 != null;
        boolean eq;
        if (e1 instanceof Object[] && e2 instanceof Object[])
            eq = deepEquals ((Object[]) e1, (Object[]) e2);
        else if (e1 instanceof byte[] && e2 instanceof byte[])
            eq = equals((byte[]) e1, (byte[]) e2);
        else if (e1 instanceof short[] && e2 instanceof short[])
            eq = equals((short[]) e1, (short[]) e2);
        else if (e1 instanceof int[] && e2 instanceof int[])
            eq = equals((int[]) e1, (int[]) e2);
        else if (e1 instanceof long[] && e2 instanceof long[])
            eq = equals((long[]) e1, (long[]) e2);
        else if (e1 instanceof char[] && e2 instanceof char[])
            eq = equals((char[]) e1, (char[]) e2);
        else if (e1 instanceof float[] && e2 instanceof float[])
            eq = equals((float[]) e1, (float[]) e2);
        else if (e1 instanceof double[] && e2 instanceof double[])
            eq = equals((double[]) e1, (double[]) e2);
        else if (e1 instanceof boolean[] && e2 instanceof boolean[])
            eq = equals((boolean[]) e1, (boolean[]) e2);
        else
            eq = e1.equals(e2);
        return eq;
    }

若参数是基本类型的数组，则根据该类型调用Arrays.equals方法。

Arrays工具类依照八种基本类型对equals方法做了重载。

5.3. hashCode

    public static int hashCode(Object o) {
        return o != null ? o.hashCode() : 0;
    }

判断引用o所指对象是否为null，不为null，则返回o所指对象的hasCode方法执行结果，为null，返回0。

5.4. hash

    public static int hash(Object... values) {
        return Arrays.hashCode(values);
    }

为一系列的输入值生成哈希码，该方法的参数是可变参数。

它将所有的输入值都放到一个数组，然后调用Arrays.hashCode(Object[])方法来实现哈希码的生成。

警告:

当提供的参数是单个对象的引用时，返回值不等于该对象引用的散列码。

这个值可以通过调用hashCode(Object)方法来计算。

public static int hashCode(Object a[ ])

实现方法如下：

    public static int hashCode(Object a[]) {
        if (a == null)
            return 0;

        int result = 1;

        for (Object element : a)
            result = 31 * result + (element == null ? 0 : element.hashCode());

        return result;
    }

5.5. toString

toString(Object o)

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

返回指定对象的字符串表示形式。如果参数为null，则返回字符串“null”。

String.valueOf(Object obj)方法的内部实现:

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

Object.toString()方法的内部实现:

public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

5.6. toString(Object o, String nullDefault)

    public static String toString(Object o, String nullDefault) {
        return (o != null) ? o.toString() : nullDefault;
    }

若第一个参数不是 null，则返回在第一个参数上调用 toString 的结果，否则返回第二个参数。

5.7. compare

    public static <T> int compare(T a, T b, Comparator<? super T> c) {
        return (a == b) ? 0 :  c.compare(a, b);
    }

注意：

若其中一个参数为null ，是否会抛出空指针异常NullPointerException取决于排序策略，

如果有的话，则由Comparator来决定空值null。

代码实例：

        int num1 = 100;
        int num2 = 200;
        System.out.println(Objects.compare(num2, num1, new Comparator<Integer>() {

            @Override
            public int compare(Integer o1, Integer o2) {
                if (o1 - o2 > 0){
                    return 1;
                }else{
                    return -1;
                }
            }

        }));
        System.out.println(Objects.compare(new Object(), new Object(), new Comparator<Object>() {

            @Override
            public int compare(Object o1, Object o2) {
                return o1.hashCode() - o2.hashCode();
            }

        }));

5.8. requireNonNull(T obj)

    public static <T> T requireNonNull(T obj) {
        if (obj == null)
            throw new NullPointerException();
        return obj;
    }

检查指定的对象引用是不是null 。若为null，则抛出空指针异常，否则返回对象本身。

此方法主要用于在方法和构造函数中进行参数校验，如下所示：

 public Foo(Bar bar) {
     this.bar = Objects.requireNonNull(bar);
 }

当我们通过带参的构造函数创建对象时，创建对象的同时就可以进行参数校验。

5.9. requireNonNull(T obj, String message)

    public static <T> T requireNonNull(T obj, String message) {
        if (obj == null)
            throw new NullPointerException(message);
        return obj;
    }

该方法是requireNonNull的重载方法，当被校验的参数为null时，根据第二个参数message抛出自定义的

NullPointerException 。

注：此方法主要用于在具有多个参数的方法和构造函数中进行参数校验，如下所示：

public Foo(Bar bar, Baz baz) {
     this.bar = Objects.requireNonNull(bar, "bar must not be null");
     this.baz = Objects.requireNonNull(baz, "baz must not be null");
 }

5.10. isNull

    public static boolean isNull(Object obj) {
        return obj == null;
    }

判空方法，如果参数为null则返回true，否则返回false。

5.11. nonNull

    public static boolean nonNull(Object obj) {
        return obj != null;
    }

判断非空方法，若参数是非空，返回true，否则返回false。

6. 参考文献

Java常用类-----java.util.Objects工具类详解-CSDN博客

wclass-zhengge

关注

12
点赞
踩
6

收藏

觉得还不错? 一键收藏
0
评论
API篇（Java - 工具类（Tool））（doing）

工具类定义的都是一些静态方法,每个方法都是以完成一个共用的功能为目的，它的好处就是内部都是一些静态方法, 每个方法完成一个功能，一次编写, 处处可用, 提高代码的重用性，一般建议工具类的构造器都私有化处理，因为工具类不需要创建对象！功能：返回由指定数组支持的固定大小的列表参数返回值：一个列表功能：将数组转换为字符串参数：待转化数组返回值：转化后的字符串都是将数组排序（默认升序，支持lambda，泛型）
复制链接

扫一扫