Java常用类库

Java常用类及方法

1.Ramdom类和Math类的Randon()方法

1.Math 类的 random() 方法没有参数，它默认会返回大于等于 0.0、小于 1.0 的 double 类型随机数，即 0<=随机数<1.0

2.Random类的常用方法：Random中常用方法都是非静态的

1.random.nextInt()的作用是随机生成一个int类型数据,因为int 的取值范围是 -2147483648——2147483647 ，所以生成的数也是处于这个范围

2.random.nextInt(int bound)方法的作用是生成一个0-参数bound范围内的随机数，但是要记住，参数bound必须是正数，不可为负数，否则在运行时会报java.lang.IllegalArgumentException: bound must be positive的错误，提示bound必须是正数.

3.random.nextLong()会随机生成一个Long类型，同理，因为Long的取值范围是 -9223372036854775808——9223372036854775807，所以也会生成一个这个区间的数。

4.random.nextDouble()会生成一个0.0-1.0之间的随机double数

5.random.nextFloat()会生成一个随机的0.0-1.0之间的浮点型数

import java.util.Random;
public class Day02 {
    public static void main(String[] args) {
        Random r = new Random();
        double d1 = r.nextDouble(); // 生成[0,1.0]区间的小数
        double d2 = r.nextDouble() * 7; // 生成[0,7.0]区间的小数
        int i1 = r.nextInt(); // 生成随机整数
        int i2 = r.nextInt(18) - 3; // 生成[-3,15)区间的整数
        int i3 = r.nextInt(10);// 生成[0,10)区间的整数
        long l1 = r.nextLong(); // 生成一个随机长整型值
        boolean b1 = r.nextBoolean(); // 生成一个随机布尔型值
        float f1 = r.nextFloat(); // 生成一个随机浮点型值
        //Math 类的 random() 方法没有参数，它默认会返回大于等于 0.0、小于 1.0 的 double 类型随机数，即 0<=随机数<1.0,
        // 对 random() 方法返回的数字稍加处理，即可实现产生任意范围随机数的功能。
        int a= (int) (Math.random()*10);//0-10
        System.out.println("生成的[0,1.0]区间的小数是：" + d1);
        System.out.println("生成的[0,7.0]区间的小数是：" + d2);
        System.out.println("生成的随机整数是：" + i1);
        System.out.println("生成的[-3,15]区间的整数是：" + i2);
        System.out.println("生成的[0,10]取件的整数是：" + i3);
        System.out.println("生成一个随机长整型值：" + l1);
        System.out.println("生成一个随机布尔型值：" + b1);
        System.out.println("生成一个随机浮点型值：" + f1);
        System.out.println("对 random() 方法返回的数字进行处理：" + a);

        System.out.print("下期七星彩开奖号码预测：");
        for (int i = 1; i < 8; i++) {
            int num = r.nextInt(9); // 生成[0,9]区间的整数
            System.out.print(num);
        }
    }
}
运行结果如下：
生成的[0,1.0]区间的小数是：0.4313954996482996
生成的[0,7.0]区间的小数是：6.675508659551698
生成的随机整数是：114301915
生成的[-3,15]区间的整数是：0
生成的[0,10]取件的整数是：8
生成一个随机长整型值：710871875035258655
生成一个随机布尔型值：false
生成一个随机浮点型值：0.13310826
对 random() 方法返回的数字进行处理：4
下期七星彩开奖号码预测：0570667

2.Objects类

Objects工具类，用于操作对象或在操作前检查某些条件。

Objects 与 Object 区别Object 是 Java 中所有类的基类，位于java.lang包。Objects 是 Object 的工具类，位于java.util包。它从jdk1.7开始才出现，被final修饰不能被继承，拥有私有的构造函数。它由一些静态的实用方法组成，这些方法是null-save（空指针安全的）或null-tolerant（容忍空指针的），用于计算对象的hashcode、返回对象的字符串表示形式、比较两个对象。equals方法是判断两个对象是否相等。

1.equals

在比较两个对象的时候，Object.equals方法容易抛出空指针异常。Objects.equals方法中已经做了非空判断，所以不会抛出空指针异常，它是null-save空指针安全的，而且也可以简化代码。

public class Day03 {
    public static void main(String[] args) {
       String s1="123";
       String s2="456";
       String s3=null;
        System.out.println(s1.equals(s2));//false
        System.out.println(s1.equals(s3));//false
        //空指针异常
       // Exception in thread "main" java.lang.NullPointerException
       // at day02.Day03.main(Day03.java:10)
        System.out.println(s3.equals(s1));
    }
}
class  Person{
    private  String name;
    public  String info;
}
如果equals比较的两个值来自于外部传进来的参数，那么我们就要进行非空判断，容易抛出空指针异常。
以上对象s3为空，这时它是不能调用方法的。空对象是没有方法的，会抛出空指针异常。调用空对象的属性或方法就会发生空指针异常。Object.equals方法内调用的是return (this == obj)。String类中是依据字符串内容是否相等来重定义了equals方法。

import java.util.Objects;

public class Day03 {
    public static void main(String[] args) {
       Person p1=null;
       Person p2=new Person();
        System.out.println(p1.equals(p2));//仍旧是空指针异常
        System.out.println(Objects.equals(p1,p2));//false,没有报异常
    }
}
class  Person{
   private String name;

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return name.equals(person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name);
    }
}
Objects.equals(p1,p2)没有异常是因为做了非空判断，其源码如下：a != null是关键。 a.equals(b)要想不抛出空指针，就要求a不能为空，所以先判断a是否为空，如果是空， a.equals(b)不会执行，（返回false），如果a不是空，那么 a.equals(b)继续执行。
 public static boolean equals(Object a, Object b) {
        return (a == b) || (a != null && a.equals(b));
    }

2.isNull()

isNull()判空方法，如果参数为空则返回true。从jdk1.8开始.

public class Day03 {
    public static void main(String[] args) {
       Person p1=null;      
        System.out.println(Objects.isNull(p1));//true
    }
}
其源码为：
 public static boolean isNull(Object obj) {
        return obj == null;
    }

3.nonNull()

nonNull()判断非空方法，如果参数不为空则返回true。从jdk1.8开始。

public class Day03 {
    public static void main(String[] args) {
       Person p1=null;       
        System.out.println(Objects.nonNull(p1));//false
    }
}
源码：
public static boolean nonNull(Object obj) {
        return obj != null;
    }

4.requireNonNull()

检查指定的对象引用是否为null，如果是，则抛出自定义的NullPointerException。

public class Day03 {
    public static void main(String[] args) {
       Person p1=null;
       Person p2=new Person();
       System.out.println(Objects.requireNonNull(p1));//空指针异常
       System.out.println(Objects.requireNonNull(p2));//返回对象的地址
    }
}
源码：
public static <T> T requireNonNull(T obj) {
        if (obj == null)
            throw new NullPointerException();
        return obj;
    }
 如果传递的对象为空，直接抛出异常，如果不为空，返回该对象。
 使用场景：严格要求对方传递过来的对象不能为空时，使用该方法。如果为空，就抛出异常。

3.Math类

abs()求绝对值

public class Day03 {
    public static void main(String[] args) {
        System.out.println(Math.abs(-100));//求绝对值  100
        System.out.println(Math.min(100,200));//返回最小值  100
        System.out.println(Math.max(100,200));//返回最大值  200
        System.out.println(Math.round(100.5));//四舍五入  101
        System.out.println(Math.round(-100.5));//四舍五入  -100
        //返回小于等于参数的最大整数
        System.out.println(Math.floor(3.5));//3.0
        System.out.println(Math.floor(-3.5));//-4.0
        //返回大于等于参数的最小整数
        System.out.println(Math.ceil(-3.5));//-3.0
        System.out.println(Math.ceil(3.5));//4.0

           }
}

4.Arrays类

Arrays类是专门操作数组的工具类。工具类的方法都是静态的可以直接调用。

1.toString（）返回指定数组内容的字符串表示形式。

public class Day03 {
    public static void main(String[] args) {
       int[] arr={9,1,2,3,4,5,6};
        System.out.println(Arrays.toString(arr));//[9, 1, 2, 3, 4, 5, 6]
           }
}
源码：
 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(", ");
        }
    }
    如果数组为空，返回空，如果数组长度-1等于-1，也就是长度为0，返回[]
    否则遍历数组，遍历结果拼接并将其添加到StringBuilder的对象中。（StringBuilder线程安全可变字符序列，StringBuffer线程不安全可变字符序列，String不可变字符序列）。

2.sort()

sort()将指定的数组按升序排序。

public class Day03 {
    public static void main(String[] args) {
        int[] arr = {9, 1, 2, 3, 4, 5, 6};
        System.out.println(Arrays.toString(arr));//[9, 1, 2, 3, 4, 5, 6]
        Arrays.sort(arr);//排序
        System.out.println(Arrays.toString(arr));//[1, 2, 3, 4, 5, 6, 9]
    }
}

3.binarySearch()

二分查找。二分查找的前提是数组为有序数组。

public class Day03 {
    public static void main(String[] args) {
        int[] arr = {9, 1, 2, 3, 4, 5, 6};
        System.out.println(Arrays.toString(arr));//[9, 1, 2, 3, 4, 5, 6]
        Arrays.sort(arr);//排序
        System.out.println(Arrays.toString(arr));//[1, 2, 3, 4, 5, 6, 9]
        //二分查找，返回查找元素的索引位置
        System.out.println(Arrays.binarySearch(arr,4));//3
    }
}

4.copyOf()

将数组扩容。

public class Day03 {
    public static void main(String[] args) {
        int[] arr = {9, 1, 2, 3, 4, 5, 6};        
        System.out.println(arr.length);//扩容前的长度为7
        arr=Arrays.copyOf(arr,10);//扩容
        System.out.println(arr.length);//扩容后的长度为10
    }
}

5.BigDecimal类

public class Day03 {
    public static void main(String[] args) {
        System.out.println(0.1+0.2);//0.30000000000000004
        System.out.println(0.3-0.1);  //  0.19999999999999998   
    }
}
那为什么会出现这种情况呢？
因为不论是float 还是double都是浮点数，而计算机是二进制的，浮点数会失去一定的精确度。
注:根本原因是:十进制值通常没有完全相同的二进制表示形式;十进制数的二进制表示形式可能不精确。只能无限接近于那个值.
    Java在java.math包中提供的API类BigDecimal，用来对超过16位有效位的数进行精确的运算。双精度浮点型变量double可以处理16位有效数。在实际应用中，需要对更大或者更小的数进行运算和处理。float和double只能用来做科学计算或者是工程计算，在商业计算中要用java.math.BigDecimal。BigDecimal所创建的是对象，我们不能使用传统的+、-、*、/等算术运算符直接对其对象进行数学运算，而必须调用其相对应的方法。方法中的参数也必须是BigDecimal的对象。构造器是类的特殊方法，专门用来创建对象，特别是带有参数的对象。
1.构造器描述 
BigDecimal(int)       创建一个具有参数所指定整数值的对象。 
BigDecimal(double) 创建一个具有参数所指定双精度值的对象。 //不推荐使用
BigDecimal(long)    创建一个具有参数所指定长整数值的对象。 
BigDecimal(String) 创建一个具有参数所指定以字符串表示的数值的对象。//推荐使用
2.方法描述 
add(BigDecimal)        BigDecimal对象中的值相加，然后返回这个对象。 
subtract(BigDecimal) BigDecimal对象中的值相减，然后返回这个对象。 
multiply(BigDecimal)  BigDecimal对象中的值相乘，然后返回这个对象。 
divide(BigDecimal)     BigDecimal对象中的值相除，然后返回这个对象。 
toString()                将BigDecimal对象的数值转换成字符串。 
doubleValue()          将BigDecimal对象中的值以双精度数返回。 
floatValue()             将BigDecimal对象中的值以单精度数返回。 
longValue()             将BigDecimal对象中的值以长整数返回。 
intValue()               将BigDecimal对象中的值以整数返回。
参考：https://blog.csdn.net/qq_35868412/article/details/89029288

public class Day03 {
    public static void main(String[] args) {
        System.out.println(0.1+0.2);//0.30000000000000004
        System.out.println(0.3-0.1);//0.19999999999999998
        BigDecimal b1=new BigDecimal("0.1");//BigDecimal(String)构造器
        BigDecimal b2=new BigDecimal("2.2");//BigDecimal(String)构造器
        BigDecimal be=new BigDecimal(2.2);//BigDecimal(double)构造器
       BigDecimal b3=b1.add(b2);//加
        int b4= b3.intValue();//将BigDecimal转成int
        double bb=b3.doubleValue();//将BigDecimal转成double
        BigDecimal b5=b1.subtract(b2);//减
        BigDecimal b6=b1.multiply(b2);//乘
        BigDecimal b7=b2.divide(b1);//除
        System.out.println(b1);//0.1
        System.out.println(b2);//2.2
        System.out.println(b3);//2.3
        System.out.println(b4);//2
        System.out.println(bb);//2.3
        System.out.println(b5);//-2.1
        System.out.println(b6);//0.22
        System.out.println(b7);//22
         System.out.println(be);//2.20000000000000017763568394002504646778106689453125
    }
}
BigDecimal(double)  不推荐使用的原因：
如上输出结果，b1,b2是BigDecimal(String)构造器，be是BigDecimal(double)构造器。
为什么会出现这种情况呢？
 JDK的描述：
 1.参数类型为double的构造方法的结果有一定的不可预知性。有人可能认为在Java中写入newBigDecimal(0.1)所创建的BigDecimal正好等于 0.1（非标度值 1，其标度为 1），但是它实际上等于0.1000000000000000055511151231257827021181583404541015625。这是因为0.1无法准确地表示为 double（或者说对于该情况，不能表示为任何有限长度的二进制小数）。这样，传入到构造方法的值不会正好等于 0.1（虽然表面上等于该值）。
 2.另一方面，String 构造方法是完全可预知的：写入 newBigDecimal("0.1") 将创建一个 BigDecimal，它正好等于预期的 0.1。因此，比较而言，通常建议优先使用String构造方法

当double必须用作BigDecimal的源时，请使用Double.toString(double)转成String，然后使用String构造方法，或使用BigDecimal的静态方法valueOf，如下
public class Day03 {
    public static void main(String[] args) {
        BigDecimal intStr = BigDecimal.valueOf(3.66666);
        BigDecimal douStr = new BigDecimal(Double.toString(3.666666));
        System.out.println(intStr);//3.66666
        System.out.println(douStr);//3.666666
    }
}

6.Date类

Date类表示特定的时刻，精度为毫秒。

1.Date类的构造器有：

1. Date（）：分配Date对象并初始化此对象，以表示分配它的时间（精确到毫秒）。

2. Date（long date）：分配 Date 对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，即 1970 年 1 月 1 日 00:00:00 GMT）以来的指定毫秒数。

3. public class Day03 {
       public static void main(String[] args) {
           //创建一个当前时间的Date
           Date d=new Date();Sun Aug 29 12:57:16 CST 2021
           System.out.println(d);//获取当前日期  Sun Aug 29 12:57:16 CST 2021
           System.out.println(d.toString());//获取当前日期  Sun Aug 29 12:57:16 CST 2021
           System.out.println(d.getTime());//1630213036420
           long longValue=d.getTime();//获取毫秒
           System.out.println(longValue);//1630213036420
           Date d2=new Date();
           d2.setTime(longValue);//把毫秒转成具体日期
           System.out.println(d2.toString());//Sun Aug 29 12:57:16 CST 2021
       }
   }
   2.方法：
   getTime（）方法来获取毫秒数，其返回值类型是long，其可以把日期对象转成毫秒值。
   setTime（long time）：表示的是time毫秒的时间点，其返回值类型是void，其可以把毫秒值转成具体日期。

   3.时间格式化显示SimpleDateFormat类

   第一：Date 转 String

   • 使用SimpleDateFormat 和 父类 DateFormat （抽象类）的 format()方法。

     public class Day03 {
        public static void main(String[] args) {
             //创建一个当前时间的Date
             Date d=new Date();
             String time1 = new SimpleDateFormat("yyyy-MM-dd HH:mmss").format(d) ;
             System.out.println(time1);//2021-08-29 13:3850
             SimpleDateFormat f=new SimpleDateFormat("yyyy年MM月dd日 HH:mm");
            //将d对象转换为字符串  yyyy年MM月dd日 HH:mm
             String time2=f.format(d);
             System.out.println(time2);//2021年08月29日 13:38
             System.out.println(d);//Sun Aug 29 13:38:50 CST 2021
         }
     }

     第二：String转Date

同样使用SimpleDateFormat 的 父类 DateFormat （抽象类）的方法，parse()

public class Day03 {
    public static void main(String[] args) throws ParseException {
        //创建一个当前时间的Date
        SimpleDateFormat f=new SimpleDateFormat("yyyy年MM月dd日 HH:mm");
        String time2=f.format(d);
        Date date=f.parse("2021年09月09日 20:12 09");//这个参数的格式应该和SimpleDateFormat f=new SimpleDateFormat("yyyy年MM月dd日 HH:mm");保持一致，如果写成 Date date=f.parse("2021-09-09 20:12 09")就会报错
        System.out.println(date);//Thu Sep 09 20:12:00 CST 2021

    }
}

7.Calendar类

1、 如何创建 Calendar 对象Calendar 是一个抽象类, 无法通过直接实例化得到对象. 因此, Calendar 提供了一个方法 getInstance,来获得一个Calendar对象, 得到的 Calendar 由当前时间初始化.

Calendar 中 set 和 get 时间都是通过在参数中填入不同的字段来实现的

public class Day03 {
    public static void main(String[] args) throws ParseException {
        Calendar c1 = Calendar.getInstance();
        c1.set(Calendar.YEAR, 2021);//设置值
        int year = c1.get(Calendar.YEAR);//获取值
        int day = c1.get(Calendar.DAY_OF_YEAR);
        System.out.println(year);//2021
        System.out.println(day);//241
    }
}

1.YEAR默认情况下指示为年份.例子中 YEAR 为 1998

2.MONTH指示当前年中的月份数,一年中的一月的值为 0需要注意的是 JANUARY, FEBRUARY, MARCH, APRIL, MAY, JUNE, JULY, AUGUST, SEPTEMBER, OCTOBER, NOVEMBER, DECEMBER 分别与 [0, 11] 对应, 在设置和获取日期时要格外注意

3.WEEK_OF_YEAR指示当前年中的星期数. 一年中的第一个星期的值为 1.例子中 WEEK_OF_YEAR 为 9

4.WEEK_OF_MONTH指示当前月中的星期数. 一个月中第一个星期的值为 1.例子中 WEEK_OF_MONTH 为 5

5.DAY_OF_MONTH指示一个月中的某天. 它与 DATE 是同义词. 一个月中第一天的值为 1.例子中 DAY_OF_MONTH 为 28

6.DATE同 DAY_OF_MONTH

7.DAY_OF_YEAR指示当前年中的天数. 一年中第一天的值为 1.

例子中 DAY_OF_YEAR 为 59

8.DAY_OF_WEEK指示一个星期中的某天, 一周中第一天的值为 1.需要 注意 的是, 与中国人的习惯不同, 此处一周中的第一天为 周日. 一周的顺序依次为: 周日(1), 周一(2), 周二(3), 周三(4), 周四(5), 周五(6), 周六(7) 在设置和获取日期时要格外注意

原文链接：https://blog.csdn.net/a1439775520/article/details/98442556

2.add()方法，对年月日进行操作

public class Day03 {
    public static void main(String[] args) throws ParseException {
        Calendar c1 = Calendar.getInstance();
        c1.set(Calendar.YEAR, 2021); //设置值
       c1.add(Calendar.YEAR,1);//将年份+1
        System.out.println(c1.get(Calendar.YEAR));//2022
        c1.add(Calendar.MONTH,-3);//月份-3
        System.out.println(c1.get(Calendar.MONTH));//4  ,月份对应的下标为[0, 11]，当前为8月，下标为7，-3为4    
        Date d1=c1.getTime();//获取以上修改后的c1的内容
        System.out.println(d1);//Sun May 29 14:18:43 CST 2022
         int m=c1.getActualMaximum(Calendar.MONTH);//获取最大的月份
        System.out.println(m);//11
        int n=c1.getActualMaximum(Calendar.DAY_OF_MONTH);//获取当前月的最大值
        System.out.println(n);//31  ,当前为8月
    }
}

8.System类

2.System类常用的方法：

1. arraycopy(Object src, int srcPos, Object dest, int destPos, int length); 将数组中指定的数据拷贝到另一个数组中。

①参数详解：

src：原数组。

srcPos：原数组中的起始位置，也就是从原数组的哪一位开始拷贝。

dest：目标数组。

destPos：目标数据中的起始位置，也就是从目标数组的哪一个位置开始存储要拷贝的元素。

length：要复制的数组元素的数量。

public class Day03 {
    public static void main(String[] args) throws ParseException {
       int [] srcArr={1,4,6,9,12};
       int[] destArr=new int[4];
       System.arraycopy(srcArr,2,destArr,1,2);
        System.out.println("目标数组的元素为"+ Arrays.toString(destArr));//目标数组的元素为[0, 6, 9, 0]
    }
}

2.currentTimeMillis();

①该方法用于获取当前系统时间，返回的是毫秒值。返回当前时间与协调世界时 1970 年 1 月 1 日午夜之间的时间差（以毫秒为单位测量）

public class Day03 {
    public static void main(String[] args) throws ParseException {
        System.out.println("系统当前时间"+System.currentTimeMillis());//系统当前时间1630220992252
    }
}

3.gc();

①该方法用来建议jvm赶快启动垃圾回收器回收垃圾。只是建议启动，但是Jvm是否启动又是另外一回事。

4.getenv(String name);

①该方法用来根据环境变量的名字获取环境变量。

public class Day03 {
    public static void main(String[] args) throws ParseException {
        System.out.println("环境变量"+System.getenv("path"));
//环境变量C:\Windows\system32;C:\Windows;C:\Windows\System32\Wbem;C:\Windows\System32\WindowsPowerShell\v1.0\;C:\Windows\System32\OpenSSH\;C:\Program Files\Java\jdk-11.0.6\bin;C:\Users\lenovo\AppData\Local\Microsoft\WindowsApps;
}

5.exit(int status);

①该方法用于退出jvm，如果参数是0表示正常退出jvm，非0表示异常退出jvm。

②退出jvm后，后面的代码就不会执行。无论传0还是传1，Jvm都会退出。③注意：0或者非0的数据都可以退出Jvm,对于用户而言没有任何区别，对于windows是有作用的，因为如果传非0对于windows而言是异常终止的，如果是正版的操作系统，对于异常退出的软件，需要把这些异常退出的软件信息做成报告发送给微软，微软就可以针对这些问题对系统做出一些修改。④我们程序员的编程习惯是：如果在try块中退出Jvm，try块里面是没有异常的代码，所以try块中要传0，如果是在catch块里面退出Jvm，我们习惯于用非0退出。

​

​

原文链接：https://blog.csdn.net/zhuwei1035838807/article/details/79464195