Java中的常用类（Arrays类，Math类，Random类，System类）

1.Arrays类

• 针对数组进行操作的工具类，提供了排序查找等功能

成员方法

• public static String toString(int [] a) 返回指定数组内容的字符串表示形式。
• public static void sort(int [] a) 对指定的 int 型数组按数字升序进行排序。
• public static void sort(int[] a, int fromIndex, int toIndex) 对指定 int 型数组的指定范围按数字升序进行排序。
• public static int binarySearch(int [] a) 使用二分搜索法来搜索指定的 int 型数组，以获得指定的值。
• public static void copyOf(int[] original, int newLength) 复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。

import java.util.Arrays;

public class Mytest {
    public static void main(String[] args) {
        int[] a = {35,45,67,68,79,345,12,23,34};
        //排序
        Arrays.sort(a);
        //输出数组
        System.out.println(Arrays.toString(a));
        //二分查找指定元素
        int i = Arrays.binarySearch(a, 68);
        System.out.println(i);
        //复制数组，截取
        int[] ints = Arrays.copyOf(a, 6);
        System.out.println(Arrays.toString(ints));
    }
}

运行结果为：

[12, 23, 34, 35, 45, 67, 68, 79, 345]
6
[12, 23, 34, 35, 45, 67]

2.Math类
  Math类包含用于执行基本数学运算的方法，如初等函数，对数，平方根和三角函数。
成员变量

• public static final double E : 自然底数（Double）
• public static final double PI: 圆周率 (Double)

成员方法

• public static int abs(int a) 取绝对值
• public static double ceil(double a) 向上取整
• public static double floor(double a) 向下取整
• public static int max(int a,int b) 获取最大值
• public static int min(int a, int b) 获取最小值
• public static double pow(double a,double b) 获取a的b次幂
• public static double random() 获取随机数 返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。
• public static int round(float a) 四舍五入
• public static double sqrt(double a)获取正平方根

public class Mytest1 {
    public static void main(String[] args) {
        int i = Math.abs(-1);
        //向上取整
        double i1 = Math.ceil(2.3);
        //向下取整
        double i2 = Math.floor(2.3);
        int i3 = Math.max(2, 3);
        int i4 = Math.min(2, 3);
        //获取2的4次幂
        double i5 = Math.pow(2, 4);
        //获取随机数，返回带蒸好的double值，该值大于等于0.0，小于1.0
        double i6 = Math.random();
        long i7 = Math.round(3.4);
        double i8 = Math.sqrt(2);
        System.out.println(i);
        System.out.println(i1);
        System.out.println(i2);
        System.out.println(i3);
        System.out.println(i4);
        System.out.println(i5);
        System.out.println(i6);
        System.out.println(i7);
        System.out.println(i8);
        //获取圆周率并且乘以三
        System.out.println(Math.PI * 3);
        //获取自然底数
        System.out.println(Math.E);
    }
}

运行结果为：

1
3.0
2.0
3
2
16.0
0.089648677557567
3
1.4142135623730951
9.42477796076938
2.718281828459045

3.Random类
  1.此类的实例用于生成伪随机数流。
  2.如果用相同的种子创建两个 Random 实例，则对每个实例进行相同的方法调用序列，它们将生成并返回相同的数字序列。为了保证此属性的实现，为类 Random 制定了特定的算法。
  3.Random 类实现的算法使用了一个 protected 实用工具方法，每次调用它最多可提供 32 个为随机生成的为，在很多应用程序里面可以发现 Math.random() 方法更易使用。

构造方法

• public Random() 没有给定种子,使用的是默认的(当前系统的毫秒值)
• public Random(long seed) 给定一个long类型的种子,给定以后每一次生成的随机数是相同的

成员方法

• public int nextInt()//没有参数 表示的随机数范围 是int类型的范围
• public int nextInt(int n)//可以指定一个随机数范围
• void nextBytes(byte[] bytes) 生成随机字节并将其置于用户提供的空的 byte 数组中。

不带种子的随机数生成器每一次结果都是不一样的

import java.util.Arrays;
import java.util.Random;

public class Mytest2 {
    public static void main(String[] args) {
        //创建一个随机数生成器
        Random random = new Random();
        //返回下一个伪随机数，它是此随机数生成器的序列中均匀分布的 int 值。
        //int nextInt ()
        int i = random.nextInt();
        //返回下一个为随机数，取自此随机数生成序列的在0(包括)到指定值（不包括）之间均匀分布的int值
        //int nextInt ( int n)
        int i1 = random.nextInt(10);
        byte[] bytes = new byte[6];
        // 生成随机字节并将其置于用户提供的 byte 数组中。
        random.nextBytes(bytes);
        System.out.println(Arrays.toString(bytes));
        System.out.println(i);
        System.out.println(i1);
    }
}

运行结果为：

[-119, 69, -92, -39, -63, 105]
-656704339
5

使用单个long种子创建一个新的随机数生成器，每一次的输出结果是一样的。

import java.util.Random;

public class Mytest3 {
    public static void main(String[] args) {

        //使用单个 long 种子创建一个新的随机数生成器
        Random random = new Random(55L);
        for (int i = 0; i < 3; i++) {
            int i1 = random.nextInt();
            System.out.println(i1);
        }
        Random random1 = new Random();
        random1.setSeed(55L);
        for (int i = 0; i < 3; i++) {
            int i1 = random.nextInt();
            System.out.println(i1);
        }
    }
}

运行结果为：

-1162794806
-244584937
1983759278
-742418317
2031813485
539284930

import java.util.Random;

public class Mytest4 {
    public static void main(String[] args) {
        Random random = new Random(23L);
        int i = random.nextInt(10);
        System.out.println(i);

    }
}

上面的程序带有种子，每次的运行结果都是一样的。
5.System类
  System类包含一些有用的类字段和方法，它不能被实例化。
成员方法

• public static void gc() 调用垃圾回收器
• public static void exit(int status) 退出java虚拟机 0 为正常退出 非0为 异常退出
• public static long currentTimeMillis()//获取当前时间的毫秒值

public class Mytest5 {
    public static void main(String[] args) {
        System.out.println("1");
        System.out.println("2");
        System.exit(0);
        System.out.println("3");
    }
}

运行结果为：

1
2

在上面代码中可以看出在执行 System.exit(0);开始退出Java虚拟机，所以后面的输出3就没有执行。

public class Mytest6 {
    public static void main(String[] args) {
        Object o = new Object();
        o = null;
        //调用垃圾回收器，是运行处于挂起终止状态的所有对象终止方法
        System.gc();
        //获取当前时间的毫秒值
        long l = System.currentTimeMillis();
        for (int i = 0; i < 100000; i++) {
            System.out.println("woaijava");
        }
        long l1 = System.currentTimeMillis();
        System.out.println(l1 - l);//结果为1477
    }
}

可以根据获取当前时间毫秒值可以推断出一个程序的运行时间。

import java.io.InputStream;
import java.io.PrintStream;
import java.util.Scanner;

public class Mytest7 {
    public static void main(String[] args) {
        //in
        //public static final InputStream in“标准”输入流。此流已打开并准备提供输入数据。通常，此流对应于键盘输入
        //out
        //public static final PrintStream out“标准”输出流。此流已打开并准备接受输出数据。通常，此流对应于显示器
        InputStream in = System.in;
        final Scanner scanner = new Scanner(in);
        PrintStream out = System.out;
        out.println("shuijiao ");
        //红色输出，可以凸显当错误时的输出颜色
        System.err.println("122334");
    }
}

运行结果为：

shuijiao 
122334