目录
static void sort(T[] a, Comparator c) 源码解读：
使用冒泡排序模拟：static void sort(T[] a, Comparator c) 方法：
使用 static void sort(T[] a, Comparator c) 方法 排序对象数组中的元素（对象）：（封装+继承+多态+多态动态绑定机制+面向接口编程）
BigInteger类（大的整数）、BigDecimal类（大的小数）
数学相关的类：Math
，Math在 java.lang包下，直接使用，无需导包。- Math 的 UML类图：
，Math被final所修饰，不可被继承。
，构造器私有化，不能创建Math的对象。（只能是 Math 类 自己在自己的类中使用自己的对象。）- Math类内部所有的 属性、方法都是 静态的，被static 修饰，直接用类名.静态成员 访问即可。
，如果本类中的静态成员有和静态导入的类的静态成员重名时，在运行程序调用静态成员的时候，优先调用的是本类中的静态成员！没有，则是使用静态导入的类中的静态成员！-
Math类中常用的API：
public static void invokeMath() { // 常用属性 //Math.E: double值比其他任何一个都更接近 e ，自然对数的基数。ln System.out.println("自然对数的基数: " + Math.E); //Math.PI：double值比任何其他的更接近 pi ，圆周长与其直径的比率。 System.out.println("圆周率 = " + Math.PI); // 常用方法 //1： // static double abs(double a)： 返回值为 double绝对值。 // static float abs(float a)： 返回值为 float 绝对值。 // static int abs(int a)： 返回值为 int 绝对值。 // static long abs(float a)： 返回为 long 值的绝对值。 System.out.println("-3.345的绝对值 = " + Math.abs(-3.345)); //2：static double pow(double a, double b) 将第一个参数的值返回到第二个参数的幂。 System.out.println("2^10的幂 = " + Math.pow(2, 10)); //3：static int decrementExact(int a) 返回一个递减1的参数，如果结果溢出int，则 "integer overflow" 。 // static long decrementExact(long a) 将返回的参数递减1，如果结果溢出long，则 "long overflow"。 System.out.println("Integer.MAX_VALUE 递减 = " + Math.decrementExact(Integer.MAX_VALUE)); // static int incrementExact(int a)返回增加1的参数，如果实参溢出int，则 integer overflow 。 //static long incrementExact(long a)返回一个增加1的参数，如果实参溢出long，则 long overflow。 System.out.println("Integer.MAX_VALUE-1 递增 = " + Math.incrementExact(Integer.MAX_VALUE - 1)); //4：static double ceil(double a)返回大于或等于参数的最小（最接近负无穷大） double值，等于一个数学整数。 System.out.println("6.000001向上取整 = " + Math.ceil(6.000001)); //5:static double floor(double a)返回小于或等于参数的最大（最接近正无穷大） double值，等于一个数学整数。 System.out.println("-9.99999999 向下取整 = " + Math.floor(-9.99999999)); //6：static double sqrt()：返回的正确舍入的正平方根 double值。（不是算术平方根！！！也不是平方根！） // 4.47213595499958^2 ≈ 20 System.out.println("20的正平方根 = " + Math.sqrt(23)); //7：static long round(double a) 返回参数中最接近的 long ，其中 long四舍五入为正无穷大。 //static int round(float a) 返回参数中最接近的 int ，其中 int四舍五入为正无穷大。 System.out.println("5.5四舍五入 = " + Math.round(5.5)); //8：static long max(long a, long b) 返回两个 long的较大值。 // static int max(int a, int b)返回两个 int值中的较大值。 // static float max(float a, float b)返回两个 float的较大值。 // static double max(double a, double b)返回两个 double值中的较大值。 System.out.println("3.14 和 6.66 中的较大值 = " + Math.max(3.14, 6.66)); //9：static long min(long a, long b)返回两个 long的较小值。 // static int min(int a, int b)返回两个 int的较小值。 // static double min(double a, double b) 返回两个 double的较小值。 //static float min(float a, float b)返回两个 float的较小值。 System.out.println(" 7 和 2 中的较小值 = " + Math.min(7, 2)); //10： static int multiplyExact(int x, int y) 返回参数的乘积，如果结果溢出int，则抛出 integer overflow 。 //static long multiplyExact(long x, long y) 返回参数的乘积，如果结果溢出long，则抛出 long overflow 。 System.out.println("56 * 78 = " + Math.multiplyExact(56, 78)); // 11: static int negateExact(int a) 返回参数的否定，如果结果溢出int，则 integer overflow 。 //static long negateExact(long a) 返回参数的否定，如果结果溢出long，则 integer overflow 。 System.out.println("-8 的相反数是 = " + Math.negateExact(-8)); // 12:static double log(double a) 返回的自然对数（以 e为底） double值。 //static double log10(double a)返回一个 double的基数10对数值。 // 2.7182818284590452354^1.791759469228055 ≈ 6.0 System.out.println("6的自然对数 = " + Math.log(6)); // 10^1.5410797677766288 ≈ 34.76 System.out.println("34.76的常用对数 = " + Math.log10(34.76)); // 13:static double IEEEremainder(double f1, double f2) 根据IEEE 754标准计算两个参数的余数运算。 System.out.println("Math.IEEEremainder(7.6, 5.56) = " + Math.IEEEremainder(7.6, 5.56)); // 14: static double random()返回值为 double值为正号，大于等于 0.0 ，小于 1.0 // 返回 [0.0,1.0) 之间的随机数 System.out.println("Math.random() = " + Math.random()); // 求 2 ~ 14 [2,14] 之间的随机数 for (int i = 1; i <= (14 << 1) + 2; i++) { System.out.print("2 ~ 14 之间的随机数 ： = " + (int) ((Math.random() * (14 - 2 + 1)) + 2) + "\t\t"); if (i % 3 == 0) System.out.println(); } // 求 46 ~ 124 [46,124] 之间的随机数 System.out.println("46 ~ 124 之间的随机数 ： =" + (int) ((Math.random() * (124 - 46 + 1)) + 46)); }result：
随机数相关的类：Random
，Random类在java.util包，使用时需要导包。- Random类 UML类图：
- Random类 构造器：
-
Random类常用API：
public static void invokeRandom() { // 利用带参数构造器初始化 Random对象： // Random(long seed) 使用单个 long种子创建一个新的随机数生成器。 // 使用单个long种子创建新的随机数生成器。 种子是通过方法next(int)维护的伪随机数发生器的内部状态的初始值。 // 调用new Random(seed)相当于： // Random rnd = new Random(); rnd.setSeed(seed); Random random = new Random(666666666666L); // int nextInt() 返回下一个伪随机数，从这个随机数发生器的序列中均匀分布 int值。 // 如果种子 每次都是一样的，那么生成的伪随机数也每次都是一样的。 System.out.println(random.nextInt()); }result：
public static void invokeRandom() { // 利用带参数构造器初始化 Random对象： // Random(long seed) 使用单个 long种子创建一个新的随机数生成器。 // 使用单个long种子创建新的随机数生成器。 种子是通过方法next(int)维护的 伪随机数发生器的内部状态的初始值。 // 调用new Random(seed)相当于： // Random rnd = new Random(); rnd.setSeed(seed); Random random = new Random(System.currentTimeMillis()); // int nextInt() 返回下一个伪随机数，从这个随机数发生器的序列中均匀分布 int值。 // 如果种子 每次都是一样的，那么生成的伪随机数也每次都是一样的。 System.out.println(random.nextInt()); // 利用空参构造器初始化 Random 对象 // 表面上是在调用无参构造器，实际底层还是调用了带参构造器 // public Random() { // this(seedUniquifier() ^ System.nanoTime()); // } Random rd = new Random(); // Random 常用方法： // int nextInt(int bound) // 返回伪随机的，均匀分布 int值介于0（含）和指定值（不包括）， 从该随机数生成器的序列绘制。 // 比如生成 1 ~ 10 之间的伪随机数 for (int i = 1; i <= (5 << 1) + 2; i++) { System.out.print("生成 1 ~ 10 之间的伪 随机数： " + (rd.nextInt(10) + 1) + "\t\t"); if (i % 3 == 0) { System.out.println(); } } System.out.println("========================================================="); // double nextDouble() // 返回下一个伪随机数，从这个随机数发生器的序列中 0.0和 1.0之间的 double值 0.0分布。 // 比如生成 89 ~ 101 之间的随机数 for (int i = 1; i <= 101 - 89; i++) { System.out.print("生成 89 ~ 101 之间的随机数： " + (int) (rd.nextDouble() * (101 - 89 + 1) + 89) + "\t\t"); if (i % 3 == 0) System.out.println(); } }result：
-
Math类中的random 方法实际上调用的就是 Random类中的 nextDouble 方法：
，实际上在Math类中 的私有 RandomNumberGenratorHolder 静态内部类中，已经初始化了 Random 的对象。
系统相关的类：System
，System 类在java.lang包下，直接使用，无需导包。
，System 被final修饰，不可被继承。构造器私有化，不能在System类以外的地方初始化 System对象。- System 的 UML 类图：
- System类中的成员，全部为静态成员，直接用 类名.静态成员调用即可。
-
System类中的常用API：
public static void invokeSystem() { // 常用属性， // static PrintStream out “标准”输出流。 // 获取“标准”输出流对象 PrintStream out = System.out; out.println("“标准”输出流"); // static InputStream in “标准”输入流。 // 获取“标准”输入流对象 InputStream in = System.in; //static PrintStream err “标准”错误输出流。 // 获取“标准” 错误输出流对象 // “标准”错误输出流 会在 “标准”输出流out.println() 的最后输出 PrintStream err = System.err; err.println("“标准”错误输出流"); // 常用方法： // (System.arraycopy方法是本地方法，由Java以外的语言实现， 由（C 或者是 C++）语言实现具体功能) // public static native void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) // 将指定源数组中的数组从指定位置复制到目标数组的指定位置。 /** * public static native void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) * src： 源数组（即拷贝的数组） * @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：拷贝的元素数量 （即从源数组中起始位置开始拷贝多少个元素到目标数组中） （从源数组中拷贝到目标数组中的最后一个元素， 这个元素在源数组中对应的索引是 （起始索引元素的索引 + 拷贝的元素数量） -1） * @param length the number of array elements to be copied. * // 如果拷贝的元素个数超出 源数组的长度， 则抛出java.lang.ArrayIndexOutOfBoundException * // 如果源数组与目标数组的类型不匹配，则抛出 java.lang.ArrayStoreException * // 如果源数组或者是目标数组 为 null 则抛出 java.lang.NullPointerException */ String[] strArr = {"java", "mysql", "redis", "spring", "netty", "dubbo"}; String[] strArr2 = new String[strArr.length + 2]; System.arraycopy(strArr, 0, strArr2, 2, strArr.length - 2); for (String s : strArr2) { out.print(s + "\t\t"); } out.println(); // static long currentTimeMillis() 返回当前时间（以毫秒为单位）。 // 返回 UTC 1970年1月1日0时到当前时间 的时间差 ，以毫秒为单位。 out.println("System.currentTimeMillis() = " + System.currentTimeMillis()); // static long nanoTime() 以纳秒为单位返回正在运行的Java虚拟机 的高分辨率时间源的当前值。 out.println("System.nanoTime() = " + System.nanoTime()); // currentTimeMillis() 和 nanoTime() 方法的区别 // 纳秒 // ns（nanosecond）：纳秒， 时间单位。一秒的10亿分之一， 即等于10的负9次方秒。常用作 内存读写速度的单位。 // 1纳秒=0.000001 毫秒 // 1纳秒=0.00000 0001秒 // System.nanoTime()返回的是纳秒，nanoTime而返回的可能是任意时间，甚至可能是负数…… // System.currentTimeMillis()返回的毫秒，这个毫秒其实就是自1970年1月1日0时起的毫秒数. // 两个方法都不能保证完全精确,精确程度依赖具体的环境. out.println("Long.MAX_VALUE = " + Long.MAX_VALUE); /** * System.nanoTime(): 此方法只能用于测量已过的时间， 与系统或钟表时间的其他任何时间概念无关。 * 返回值表示从某一固定但任意的时间算起的毫微秒数（或许从以后算起，所以该值可能为负）。 * 此方法提供毫微秒的精度，但不是必要的毫微秒的准确度。它对于值的更改频率没有作出保证。 * 在取值范围大于约 292 年（263 毫微秒）的连续调用的不同点在于： 由于数字溢出，将无法准确计算已过的时间。 * * System.currentTimeMillis()： 此方法 返回的是从1970.1.1 UTC 零点开始 到现在的时间，精确到毫秒，平时我们可以根据System.currentTimeMillis 来计算当前日期，星期几等，可以方便的与Date进行转换， * 返回以毫秒为单位的当前时间。注意，当返回值的时间单位是毫秒时， * 值的粒度取决于底层操作系统，并且粒度可能更大。例如， 许多操作系统以几十毫秒为单位测量时间。 */ // static void gc() 运行垃圾回收器。 // 当对象不再有任何引用，在执行 gc() 运行垃圾回收机制时， // 会主动先执行对象的finalize()方法里面的逻辑代码， 如果对象类中有重写Object父类的finalize() // finalize()方法，只要在对象被垃圾回收时就都会执行， 如果对象类中有重写Object的finalize() // 调用System.gc()，只是主动运行垃圾回收器 System.gc(); // static void exit(int status)终止当前运行的Java虚拟机。exit后面的任何代码都不再执行 // status : 0 表示程序正常终止，非零 表示异常终止 System.exit(0); out.println("终止虚拟机，本句代码不会再执行！"); }result:
操作数组的工具类：Arrays
- Arrays 类中包含了一系列的静态方法，用于操作数组（比如数组的排序和二分查找）
- Arrays 的 UML类图
最低0.47元/天 解锁文章
扫一扫
222
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
