JAVA篇10 —— 常用类WrapperStringMathArraysSystemBigIntegerBigDecimal日期

欢迎来到我的主页：【一只认真写代码的程序猿】

本篇文章收录于专栏【小小爪哇】

如果这篇文章对你有帮助，希望点赞收藏加关注啦~

1 包装类

基本数据类型	包装类
boolean	Boolean
char	Character
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double

包装类和基本数据类型的相互转换,这里以int 和 Integer演示（其他类似）。

jdk5 前的手动装箱和拆箱方式，装箱: 基本类型->包装类型,反之，拆箱.
jdk5 以后(含jdk5)的自动装箱和拆箱方式。
自动装箱底层调用的是valueOf方法，比如Integer.valueOf()

public class IntegerTest1 {
    public static void main(String[] args) {
        //jdk5 前是手动装箱和拆箱
        //手动装箱 int->Integer
        int n1 = 100;
        Integer integer = new Integer(n1);
        Integer integer1 = Integer.valueOf(n1);
        //手动拆箱
        //Integer -> int
        int i = integer.intValue();
        
        //jdk5 后， 就可以自动装箱和自动拆箱
        int n2 = 200;
        //自动装箱 int->Integer
        Integer integer2 = n2; //底层使用的是 Integer.valueOf(n2)
        //自动拆箱 Integer->int
        int n3 = integer2; //底层仍然使用的是 intValue()方法
        
        //现在可以直接赋
        int n22 = 200;
        Integer n22In = n22;
        //可以直接改成下述：
        Integer n222 = 200;
    }
}

1.1 包装类和String

public class WrapperVSString {
    public static void main(String[] args) {
        //Wrapper转String
        Integer i = 10;
        //方案一：加空串
        String str1 = i+"";
        //方案二：toString
        String str2 = i.toString();
        //方案三：ValueOf
        String str3 = String.valueOf(i);
        System.out.println(str1==str2);//false
        System.out.println(str1==str3);//false
        System.out.println(str2==str3);//false

        //String转Wrapper，parseInt和valueOf
        String strTest = "12345";
        Integer i2 = Integer.parseInt(strTest);
        Integer i3 = Integer.valueOf(strTest);
    }
}

1.2 int&char包装类常用方法

public class WrapperMethod {
    public static void main(String[] args) {
        System.out.println(Integer.MIN_VALUE); //返回最小值
        System.out.println(Integer.MAX_VALUE);//返回最大值
        System.out.println(Character.isDigit('a'));//判断是不是数字
        System.out.println(Character.isLetter('a'));//判断是不是字母
        System.out.println(Character.isUpperCase('a'));//判断是不是大写
        System.out.println(Character.isLowerCase('a'));//判断是不是小写
        System.out.println(Character.isWhitespace('a'));//判断是不是空格
        System.out.println(Character.toUpperCase('a'));//转成大写
        System.out.println(Character.toLowerCase('A'));//转成小写
    }
}

如果数字范围在-128到127内，则数字直接返回，否则为new Integer();下面为示例代码：

public class WrapperMethod {
    public static void main(String[] args) {
        //这里主要是看范围 -128 ~ 127 就是直接返回
        // i 在 IntegerCache.low(-128)~IntegerCache.high(127),就直接从数组返回
        int n = 1;
        int m = 1;
        System.out.println(n == m);//true
        Integer i1 = new Integer(1);
        Integer j1 = new Integer(1);
        System.out.println(i1 == j1); //False

        Integer i2 = 128;
        Integer j2 = 128;
        System.out.println(i2 == j2);//False
    }
}

ValueOf源码：

public static Integer valueOf(int i) {
    if (i >=IntegerCache.low && i <=IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}

IntegerCache源码：

private static class IntegerCache {
    static final int low = -128;
    static final int high;
    static final Integer cache[];

    static {
        // high value may be configured by property
        int h = 127;
        String integerCacheHighPropValue =
                sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
        if (integerCacheHighPropValue != null) {
            try {
                int i = parseInt(integerCacheHighPropValue);
                i = Math.max(i, 127);
                // Maximum array size is Integer.MAX_VALUE
                h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
            } catch( NumberFormatException nfe) {
                // If the property cannot be parsed into an int, ignore it.
            }
        }
        high = h;

        cache = new Integer[(high - low) + 1];
        int j = low;
        for(int k = 0; k < cache.length; k++)
            cache[k] = new Integer(j++);

        // range [-128, 127] must be interned (JLS7 5.1.7)
        assert Integer.IntegerCache.high >= 127;
    }

    private IntegerCache() {}
}

2 String类

String类 - 蜡笔小新. - CSDN

3 Math 类

1.abs 绝对值
2.pow 求幂
3.ceil 向上取整,返回>=该参数的最小整数(转成 double);
4.floor 向下取整， 返回<=该参数的最大整数(转成 double);
5.round 四舍五入 Math.floor(该参数+0.5)
6.sqrt 求开方
7.random 求随机数
8.max , min 返回最大值和最小值

package MathClas;

/**
 * @ClassName MathMethod
 * @Description
 * @Date 2024/12/1 19:05
 * @Version V1.0
 */
public class MathMethod {
    public static void main(String[] args) {
        int abs = Math.abs(-9);//9
        double pow = Math.pow(2, 4);//2 的 4 次方
        double ceil = Math.ceil(3.9);//4.0
        double floor = Math.floor(4.001);//4.0
        long round = Math.round(5.51);//6
        double sqrt = Math.sqrt(9.0);//3.0
        
        /* random 返回的是 0 <= x < 1 之间的一个随机小数
         思考： 请写出获取 a-b 之间的一个随机整数,a,b 均为整数 ， 比如 a = 2, b=7
         即返回一个数 x 2 <= x <= 7
         老韩解读 Math.random() * (b-a) 返回的就是 0 <= 数 <= b-a
         (1) (int)(a) <= x <= (int)(a + Math.random() * (b-a +1) )
         (2) 使用具体的数给小伙伴介绍 a = 2 b = 7
         (int)(a + Math.random() * (b-a +1) ) = (int)( 2 + Math.random()*6)
         Math.random()*6 返回的是 0 <= x < 6 小数
         2 + Math.random()*6 返回的就是 2<= x < 8 小数
                 (int)(2 + Math.random()*6) = 2 <= x <= 7
         (3) 公式就是 (int)(a + Math.random() * (b-a +1) )*/
        for (int i = 0; i < 10; i++) {
            System.out.println((int) (2 + Math.random() * (7 - 2 + 1)));
        }

        int min = Math.min(1, 9);
        int max = Math.max(45, 90);
        System.out.println("min=" + min);
        System.out.println("max=" + max);
    }
}

4 Arrays类

Arrays中包含一系列的static方法，用来管理操作数组
toString 返回数组的字符串形式。
sort 排序，自然排序和定制排序均可。
binarySearch 二分查找，必须是排序好的数组。
copyOf 数组元素复制。
fill 数组元素填充。
equals 两个数组元素内容是否相同。
asList 将一组值转换成List。

打印：

    public static void main(String[] args) {
        Integer[] integers = {1, 20, 90};
        //遍历
        for (int i = 0; i < integers.length; i++) {
            System.out.print(integers[i] + " ");
        }
        System.out.println(Arrays.toString(integers));//[1, 20, 90]
    }

Sort：

1. 可以直接使用冒泡排序 , 也可以直接使用 Arrays 提供的 sort 方法排序

2. 因为数组是引用类型，所以通过 sort 排序后，会直接影响到实参 arr

3. sort 重载的，也可以通过传入一个接口 Comparator 实现定制排序

4. 调用定制排序时，传入两个参数 ①排序的数组 arr ②实现了 Comparator 接口的匿名内部类 , 要求实现 compare 方法。源码如下：

    public static <T> void sort(T[] a, Comparator<? super T> c) {
        if (c == null) {
            sort(a);
        } else {
            if (LegacyMergeSort.userRequested)
                legacyMergeSort(a, c);
            else
                TimSort.sort(a, 0, a.length, c, null, 0, 0);
        }
    }

    public static void main(String[] args) {
        Integer[] arr = {0,-9,4,7,-2};
        Arrays.sort(arr, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1-o2;//升序排列
            }
        });
        System.out.println(Arrays.toString(arr));
        Arrays.sort(arr);//默认方法就是升序
        System.out.println(Arrays.toString(arr));
    }

binarySearch、copyOf、fill、asList:

package MathClas;

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

/**
 * @ClassName ArraysClass
 * @Description Arrays类的常用方法介绍
 * @Date 2024/12/1 19:29
 * @Version V1.0
 */
public class ArraysClass {
    public static void main(String[] args) {
        //1. 使用 binarySearch 二分查找
        //2. 要求该数组是有序的. 如果该数组是无序的， 不能使用 binarySearch
        //3. 如果数组中不存在该元素， 就返回 return -(low + 1); // key not found
        Integer[] arr = {1, 2, 3, 4, 5};
        int index = Arrays.binarySearch(arr, 3);
        System.out.println("3的下标是：" + index);

        //1. 从 arr 数组中， 拷贝 arr.length 个元素到 newArr 数组中
        //2. 如果拷贝的长度 > arr.length 就在新数组的后面 增加 null
        //3. 如果拷贝长度 < 0 就抛出异常 NegativeArraySizeException
        //4. 该方法的底层使用的是 System.arraycopy()
        Integer[] newArr = Arrays.copyOf(arr, arr.length);
        System.out.println("拷贝后的newArr是" + Arrays.toString(newArr));

        Integer[] nums = new Integer[]{1, 2, 3, 4};
        Arrays.fill(nums, 10);
        System.out.println("填充后的数组为：" + Arrays.toString(nums));//全10

        Integer[] num1 = new Integer[]{1, 2, 3};
        Integer[] num2 = new Integer[]{1, 2, 3};
        //Arrays的equals只负责内容是否相同
        //下面是false
        System.out.println(Arrays.equals(num1, num2));//true
        System.out.println("num1.equals(num2):" + num1.equals(num2));//false


        //1. asList 方法， 会将 (2,3,4,5,6,1)数据转成一个 List 集合
        //2. 返回的 asList 编译类型 List(接口)
        //3. asList 运行类型 java.util.Arrays#ArrayList, 是 Arrays 类的
        // 静态内部类 private static class ArrayList<E> extends AbstractList<E>
        // implements RandomAccess, java.io.Serializable
        List aList = Arrays.asList(num1);
        System.out.println("aList=" + aList);//[1, 2, 3]
        System.out.println("运行类型是：" + aList.getClass());//java.util.Arrays$ArrayList
    }
}

5 System类

exit：退出当前程序
arraycopy：复制数组元素，适用于底层调用，我们正常复制数组元素还是用Arrays.copyOf
currentTimeMillis：返回当前时间距离1970-1-1的00:00的毫秒数
gc：垃圾回收机制

    public static void main(String[] args) {
        //exit 退出当前程序
        // System.out.println("ok1");
        // //1. exit(0) 表示程序退出
        // //2. 0 表示一个状态 , 正常的状态
        // System.exit(0);//
        // System.out.println("ok2");
        //arraycopy ： 复制数组元素， 比较适合底层调用，
        // 一般使用 Arrays.copyOf 完成复制数组
        int[] src = {1, 2, 3};
        int[] dest = new int[3];// dest 当前是 {0,0,0}


        // 源码：
        /*
        public static native void arraycopy(Object src,  int  srcPos,
        Object dest, int destPos,
        int length);
        */
        // * @param src the source array. 源数组
        // srcPos： 从源数组的哪个索引位置开始拷贝
        // * @param srcPos starting position in the source array.
        // dest : 目标数组， 即把源数组的数据拷贝到哪个数组
        // * @param dest the destination array.
        // destPos: 把源数组的数据拷贝到 目标数组的哪个索引
        // * @param destPos starting position in the destination data.
        // length: 从源数组拷贝多少个数据到目标数组
        // * @param length the number of array elements to be copied
        System.arraycopy(src, 0, dest, 0, src.length);
        System.out.println("dest=" + Arrays.toString(dest));//[1, 2, 3]
        //currentTimeMillens:返回当前时间距离 1970-1-1 的毫秒数
        System.out.println(System.currentTimeMillis());
    }

6 BigInteger和BigDecimal类

BigInteger适用于存较大的整型，BigDecimal存更高精度的浮点数。BigInteger不能直接做四则运算，要用对应的方法来完成运算。

add：加法
subtract：减法
multiply：乘法
divide：除法

    public static void main(String[] args) {
        //需要处理很大的整数， long 不够用，可以使用 BigInteger 的类来搞定
        //long l = 23788888899999999999999999999L;//Long number too large
        //System.out.println("l=" + l);
        BigInteger bigInteger = new BigInteger("23788888899999999999999999999");
        BigInteger bigInteger1 = new BigInteger("100999999999999999999999999999999
99999999999999999999999999999999999999999999999999");
        System.out.println("bigInteger:" + bigInteger);
        System.out.println("bigInteger1:" + bigInteger1);
        //不能直接相加，要用方法
        BigInteger add = bigInteger.add(bigInteger1);
        System.out.println(add);
//        System.out.println(bigInteger1+bigInteger);
//Operator '+' cannot be applied to 'java.math.BigInteger', 'java.math.BigInteger'
        BigInteger subtract = bigInteger.subtract(bigInteger1);
        System.out.println(subtract);//减
        BigInteger multiply = bigInteger.multiply(bigInteger1);
        System.out.println(multiply);//乘
        BigInteger divide = bigInteger.divide(bigInteger1);
        System.out.println(divide);//除

    }

    public static void main(String[] args) {
        //当我们需要保存一个精度很高的数时， double 不够用，可以 BigDecimal
        // double d = 1999.11111111111999999999999977788d;
        // System.out.println(d);
        BigDecimal bigDecimal = new BigDecimal("1999.11");
        BigDecimal bigDecimal2 = new BigDecimal("3");
        System.out.println(bigDecimal);
        //1. 如果对 BigDecimal 进行运算， 比如加减乘除， 需要使用对应的方法
        //2. 创建一个需要操作的 BigDecimal 然后调用相应的方法即可
        System.out.println(bigDecimal.add(bigDecimal2));
        System.out.println(bigDecimal.subtract(bigDecimal2));
        System.out.println(bigDecimal.multiply(bigDecimal2));
        //System.out.println(bigDecimal.divide(bigDecimal2));//可能抛出异常 ArithmeticException
        //在调用 divide 方法时， 指定精度即可. BigDecimal.ROUND_CEILING
        //如果有无限循环小数， 就会保留 分子 的精度
        //源码中是2位
        //public static final int ROUND_CEILING = 2
        System.out.println(bigDecimal.divide(bigDecimal2, BigDecimal.ROUND_CEILING));
    }