1. 基本介绍 480
Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。
2. 方法一览(均为静态方法)
代码在com.stulzl.math_.包中 480
Math_Method
package com.stulzl.math_;
//Math类的常用方法 480
public class Math_Method {
public static void main(String[] args) {
//看看Math常用的方法(静态方法)
//1.abs 绝对值
int abs = Math.abs(-9);
System.out.println(abs);//9
//2.pow 求幂
double pow = Math.pow(2, 4);//2的4次方
System.out.println(pow);//16
//3.ceil 向上取整,返回>=该参数的最小整数(转成double);
double ceil = Math.ceil(3.9);
System.out.println(ceil);//4.0
//4.floor 向下取整，返回<=该参数的最大整数(转成double)
double floor = Math.floor(4.001);
System.out.println(floor);//4.0
//5.round 四舍五入 Math.floor(该参数+0.5)
long round = Math.round(5.51);
System.out.println(round);//6
//6.sqrt 求开方
double sqrt = Math.sqrt(9.0);
System.out.println(sqrt);//3.0
//max , min 返回最大值和最小值
int min = Math.min(1, 9);
int max = Math.max(45, 90);
System.out.println("min=" + min);
System.out.println("max=" + max);
}
}2.2 小练习 480
请写出获取 a-b之间的一个随机整数,a,b均为整数 ，比如 a = 2, b=7
即返回一个数 x 2 <= x <= 7
代码在com.stulzl.math_.包中
Exercise
package com.stulzl.math_;
public class Exercise {
public static void main(String[] args) {
//7.random 求随机数
// random 返回的是 0 <= x < 1 之间的一个随机小数[0,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)));
}
}
}3. Arrays类
3.1 Arrays 类常见方法应用案例 481
Arrays里面包含了一系列静态方法，用于管理或操作数组(比如排序和搜索)。
1) toString返回数组的字符串形式
Arrays.toString(arr)
2) sort排序(自然排序和定制排序)
Integer arr[] = {1,-1, 7, 0, 89};
3) binarySearch通过二分搜索法进行查找，要求必须排好序
int index = Arrays.binarySearch(arr, 3);
4) copyOf数组元素的复制
Integer[] newArr = Arrays.copyOf(arr, arr.length);
5) fill数组元素的填充
Integer[] num = new Integer[]{9,3,2};
Arrays.fill(num, 99);
6) equals比较两个数组元素内容是否完全一致
boolean equals = Arrays.equals(arr, arr2);
7) asList将一组值，转换成list
List asList = Arrays.asList(2,3,4,5,6,1);
System.out.println(" asList=" + asList);
代码在com.stulzl.arrays_.包中 481
ArraysMethods01
package com.stulzl.arrays_;
import java.util.Arrays;
import java.util.Comparator;
//arrays方法 481-483
public class ArraysMethods01 {
public static void main(String[] args) {
Integer[] integers = {1,20,90};
//传统方法 遍历数组
for (int i = 0; i < integers.length; i++) {
System.out.println(integers[i]);
}
//直接使用Arrays的toString方法遍历数组
System.out.println(Arrays.toString(integers));//[1, 20, 90]
//演示sort排序方法
Integer arr[] = {1,-1,7,0,89};
// 因为数组是引用类型，所以通过 sort 排序后，会直接影响到 实参 arr
Arrays.sort(arr);
System.out.println("====排序后====");
System.out.println(Arrays.toString(arr));//从小到大排
//定制排序
// sort 重载的，也可以通过传入一个接口 Comparator 实现定制排序
//4. 调用 定制排序 时，传入两个参数 (1) 排序的数组 arr
// (2) 实现了 Comparator 接口的匿名内部类 , 要求实现 compare 方法
Arrays.sort(arr, new Comparator() {
@Override
public int compare(Object o1, Object o2) {
Integer i1 = (Integer) o1;
Integer i2 = (Integer) o2;
return i2-i1;
}
});
System.out.println("====排序后====");
System.out.println(Arrays.toString(arr));//从小到大排
}
}ArraysMethods02 483
package com.stulzl.arrays_;
import java.util.Arrays;
import java.util.List;
//arrays方法02 483
public class ArraysMethods02 {
public static void main(String[] args) {
//binarySearch通过二分搜索法进行查找，要求必须排好序
Integer[] arr = {1,2,90,123,567};
// binarySearch 通过二分搜索法进行查找，要求必须排好
// 解读
//1. 使用 binarySearch 二叉查找
//2. 要求该数组是有序的. 如果该数组是无序的，不能使用 binarySearch
//3. 如果数组中不存在该元素，就返回 return -(low + 1); // key not found.
int index = Arrays.binarySearch(arr,567);
System.out.println("index="+index);
//copyOf数组元素的复制
//解读
//从arr数组中拷贝arr.length个元素到newArr数组中
//2. 如果拷贝的长度 > arr.length 就在新数组的后面 增加 null
//3. 如果拷贝长度 < 0 就抛出异常 NegativeArraySizeException
//4. 该方法的底层使用的是 System.arraycopy()
Integer newArr[] = Arrays.copyOf(arr,arr.length-1);
System.out.println("====拷贝后的数组====");
System.out.println(Arrays.toString(newArr));
// fill数组元素的填充
Integer num[] = new Integer[]{9,3,2};
Arrays.fill(num,99);
//解读
//1. 使用 99 去填充 num 数组，可以理解成是替换原来的所有元素为99
System.out.println("====填充后====");
System.out.println(Arrays.toString(num));
//equals 比较两个数组元素内容是否完全一致
Integer[] arr2 = {1, 2, 90, 123,567};
//解读
//1. 如果 arr 和 arr2 数组的元素一样，则方法 true;
//2. 如果不是完全一样，就返回 false
boolean equals = Arrays.equals(arr,arr2);
System.out.println(equals);
// asList将一组值，转换成list
//解读
//1. asList 方法，会将 (2,3,4,5,6,1)数据转成一个 List 集合
//2. 返回的 asList 编译类型 是List(接口)
//3. asList 运行类型 java.util.Arrays#ArrayList, 是 Arrays 类的 静态内部类
List asList = Arrays.asList(2,3,4,5,6,1);
System.out.println("asList="+asList);
System.out.println("asList 的运行类型" + asList.getClass());
}
}4. 自我实现自定义排序 482
代码在com.stulzl.arrays_sort_custom.包中
ArraysSortCustom
package com.stulzl.arrays_sort_custom;
import java.util.Arrays;
import java.util.Comparator;
//自我实现自定义排序 482
public class ArraysSortCustom {
public static void main(String[] args) {
int arr[] = {18,96,-7,23,2};
//bubble01(arr);
bubble02(arr, new Comparator() {//匿名内部类
@Override
public int compare(Object o1, Object o2) {
Integer i1 = (Integer)o1;
Integer i2 = (Integer)o2;
return i2-i1; //return i1-i2; //主动权 两种情况可以控制不同顺序的排序
}
});
System.out.println("====排序后====");
System.out.println(Arrays.toString(arr));
}
//使用冒泡排序
public static void bubble01(int arr[]){
for (int i = 0; i < arr.length-1; i++) {
for(int j = 0;j<arr.length-1-i;j++){
if(arr[j]>arr[j+1]){
int temp = arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
}
//结合冒泡实现定制排序
public static void bubble02(int arr[], Comparator c){//Comparator是一个接口
for (int i = 0; i < arr.length-1; i++) {
for(int j = 0;j<arr.length-1-i;j++){
//这里解释(判断式)为什么只写>0
//1. arr[j]-arr[j+1] > 0 进入交换 小-->大
//2. arr[j]-arr[j+1] < 0 进入交换 大-->小
//但是我们为了只写一个判断式，就将2小小的改动一下
// -(arr[j]-arr[j+1]) > 0 打开负号
//等价于 arr[j+1]-arr[j] > 0 进入交换 大-->小
if(c.compare(arr[j],arr[j+1])>0){//这里的>0 <0,直接影响排序的结果
int temp = arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
}
}
