目录
Math类
基本介绍
Math类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。
方法一览(均为静态方法)
Math类的常见方法
-
abs 绝对值
-
pow 求幂
-
ceil 向上取整
-
floor 向下取整
-
round 四舍五入
-
sqrt 求开方
-
random 求随机数//思考： 请写出获取a-b之间的一个随机整数，a，b均为整数?2-7
-
max 求两个数的最大值
-
min求两个数的最小值
-
练习题：获取一个a-b之间的一个随机整数.
-
int num =(int)(a + Math.random()*(b-a+1))
代码演示：
package idea.chapter13.math_;
/**
* 演示Math类的常用方法
*/
public class MathMethod {
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
//7.random 求随机数
//记住公式即可
// 公式就是 (int)(a + Math.random() * (b-a +1) )
for (int i = 0; i < 100; i++) {
System.out.println((int) (2 + Math.random() * (7 - 2 + 1)));
}
//max , min 返回最大值和最小值
int min = Math.min(1, 9);
int max = Math.max(45, 90);
System.out.println("min=" + min);
System.out.println("max=" + max);
}
}
Arrays类
Arrays类常见方法
Arrays里面包含了一系列静态方法，用于管理或操作数组(比如排序和搜索)。
代码演示：
package idea.chapter13.arrays_;
import java.util.Arrays;
import java.util.Comparator;
public class ArraysMethod01 {
public static void main(String[] args) {
Integer[] integers = {1, 20, 90};
//使用的是传统的方式去遍历输出数组，比较繁琐，在Arrays类中，提供了toString()方法，增加我们的效率
//遍历数组
// for(int i = 0; i < integers.length; i++) {
// System.out.println(integers[i]);
// }
//直接使用Arrays.toString方法，显示数组
// System.out.println(Arrays.toString(integers));//
//演示 sort方法的使用
Integer arr[] = {1, -1, 7, 0, 89};
//使用sort进行排序
//1. 可以直接使用冒泡排序 , 也可以直接使用Arrays提供的sort方法排序
//2. 因为数组是引用类型，所以通过sort排序后，会直接影响到 实参 arr
//3. sort重载的，也可以通过传入一个接口 Comparator 实现定制排序
//4. 调用 定制排序 时，传入两个参数 (1) 排序的数组 arr
// (2) 实现了Comparator接口的匿名内部类 , 要求实现 compare方法
//5. 先演示效果，再解释
//6. 这里体现了接口编程的方式 , 看看源码，就明白
// 源码分析
//(1) Arrays.sort(arr, new Comparator()
//(2) 最终到 TimSort类的 private static <T> void binarySort(T[] a, int lo, int hi, int start,
// Comparator<? super T> c)()
//(3) 执行到 binarySort方法的代码, 会根据动态绑定机制 c.compare()执行我们传入的
// 匿名内部类的 compare ()
// while (left < right) {
// int mid = (left + right) >>> 1;
// if (c.compare(pivot, a[mid]) < 0)
// right = mid;
// else
// left = mid + 1;
// }
//(4) new Comparator() {
// @Override
// public int compare(Object o1, Object o2) {
// Integer i1 = (Integer) o1;
// Integer i2 = (Integer) o2;
// return i2 - i1;
// }
// }
//(5) public int compare(Object o1, Object o2) 返回的值>0 还是 <0
// 会影响整个排序结果, 这就充分体现了 接口编程+动态绑定+匿名内部类的综合使用
// 将来的底层框架和源码的使用方式，会非常常见
//Arrays.sort(arr); // 默认排序方法
//定制排序
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));//
}
}
3.binarySearch 通过二分搜索法进行查找，要求必须排好序 int index =Arrays.binarySearch(arr,3);
-
copyOf 数组元素的复制 Integerl] newArr=Arrays.copyOf(arr,arr.length);
-
fill 数组元素的填充 Integer[] num = new Integer; Arrays.fill(num, 99);
-
equals 比较两个数组元素内容是否完全一致 韩教boolean equals =Arrays.equals(arr,arr2);
-
asList 将一组值，转换成list List<Integer> asList=Arrays.asList(2,3,4,5,6,1); 图片System.out.println("asList="+ asList);
代码演示：
package idea.chapter13.arrays_;
import java.util.Arrays;
import java.util.List;
public class ArraysMethod02 {
public static void main(String[] args) {
Integer[] arr = {1, 2, 90, 123, 567};
// binarySearch 通过二分搜索法进行查找，要求必须排好
//1. 使用 binarySearch 二叉查找
//2. 要求该数组是有序的. 如果该数组是无序的，不能使用binarySearch
//3. 如果数组中不存在该元素，就返回 return -(low + 1); 返回的就是，该元素应该存在的位置+1在取反
// 就是数据应该在的位置+1在取反
int index = Arrays.binarySearch(arr, 567);
System.out.println("index=" + index);
//copyOf 数组元素的复制
//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("==拷贝执行完毕后==");
System.out.println(Arrays.toString(newArr));
//fill 数组元素的填充
Integer[] num = new Integer[]{9, 3, 2};
//1. 使用 99 去填充 num数组，可以理解成是替换原理的元素
Arrays.fill(num, 99);
System.out.println("==num数组填充后==");
System.out.println(Arrays.toString(num));
//equals 比较两个数组元素内容是否完全一致
Integer[] arr2 = {1, 2, 90, 123};
//解读
//1. 如果arr 和 arr2 数组的元素一样，则方法true;
//2. 如果不是完全一样，就返回 false
boolean equals = Arrays.equals(arr, arr2);
System.out.println("equals=" + equals);
//asList 将一组值，转换成list
//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 asList = Arrays.asList(2, 3, 4, 5, 6, 1);
System.out.println("asList=" + asList);
//注意运行类型是，Arrays类中的一个内部类
System.out.println("asList的运行类型" + asList.getClass());
}
}定制排序
代码演示：
package idea.chapter13.arrays_;
import java.util.Arrays;
import java.util.Comparator;
/**
* 自己实现定制排序
*/
public class ArraysSortCustom {
public static void main(String[] args) {
int[] arr = {1, -1, 8, 0, 20};
//使用冒泡排序
//bubble01(arr);
//使用自己的定制排序
//这是一个匿名内部类
bubble02(arr, new Comparator() {
@Override
public int compare(Object o1, Object o2) {
int n1 = (Integer) o1;
int n2 = (Integer) o2;
return n1 - n2;
}
});
System.out.println(Arrays.toString(arr));
}
//使用定制排序
public static void bubble02(int arr[], Comparator c) {
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - 1 - i; j++) {
if (c.compare(arr[j], arr[j + 1]) > 0) {
int tmp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = tmp;
}
}
}
}
//使用冒泡排序
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 tmp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = tmp;
}
}
}
}
}Arrays课堂练习
代码演示：
package idea.chapter13.arrays_;
import java.util.Arrays;
import java.util.Comparator;
/*
自定义Book类，里面包含name和price，按price排序(从大到小)。要求使用两种方式排序，有一个Book]books=4本书对象.
使用前面学习过的传递 实现Comparator接口匿名内部类，也称为定制排序。[同学们完成这个即可10min]，可以按照 price(1)从大到小(2)从小到大(3)按照书名长度从大到小
Book[] books = new Book[4];
books[0]=new Book("红楼梦”，100);
books[1]=new Book("金瓶梅新"，90)；
books[2]=new Book("青年文摘20年",5)；
books[3]=new Book("java从入门到放弃~"，300)；
*/
public class ArrayExercise {
public static void main(String[] args) {
Book[] books = new Book[4];
books[0] = new Book("红楼梦", 100);
books[1] = new Book("金瓶梅新", 90);
books[2] = new Book("青年文摘20年", 5);
books[3] = new Book("java从入门到放弃~", 300);
//从小到大
Arrays.sort(books, new Comparator<Book>() {
@Override
public int compare(Book o1, Book o2) {
return o1.getPrice() - o2.getPrice();
}
});
System.out.println(Arrays.toString(books));
//从大到小
Arrays.sort(books, new Comparator<Book>() {
@Override
public int compare(Book o1, Book o2) {
return o2.getPrice() - o1.getPrice();
}
});
System.out.println(Arrays.toString(books));
//按照名字长度进行排序
Arrays.sort(books, new Comparator<Book>() {
@Override
public int compare(Book o1, Book o2) {
return o1.getName().length()-o2.getName().length();
}
});
System.out.println(Arrays.toString(books));
}
}
class Book {
private String name;
private int price;
public Book(String name, int price) {
this.name = name;
this.price = price;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getPrice() {
return price;
}
public void setPrice(int price) {
this.price = price;
}
@Override
public String toString() {
return "Book{" +
"name='" + name + '\'' +
", price=" + price +
'}';
}
}
System类
System类常见方法
1.exit退出当前程序
2.arraycopy：复制数组元素，比较适合底层调用，一般使用Arrays.copyOf完成复制数组. int[] src=(1,2,3); int[] dest =new int[3]; System.arraycopy(src,0, dest,0, 3);
3.currentTimeMillens：返回当前时间距离1970-1-1的毫秒数
4.gc:运行垃圾回收机制System.gc();
思路分析：
arraycopy五个参数的含义
//第一个参数的含义是拷贝的原数组 //第二个参数的含义是从原数组的第几个下标开始拷贝 //第三个参数的含义是拷贝的那个数组去。就是把原数组拷贝到一个新的数组 //第四个参数的含义是从新数组的那个下标开始接收原数组拷贝的内容 //第五个参数的含义是，要拷贝的长度是多少
package idea.chapter13.system_;
import java.util.Arrays;
public class System_ {
public static void main(String[] args) {
//exit 退出当前程序
// System.out.println("ok1");
// //1. exit(0) 表示程序退出
// //2. 0 表示一个状态 , 正常的状态
// System.exit(0);
//因为这里我们已经退出了程序，所以ok2并不会输出
// System.out.println("ok2");
//arraycopy ：复制数组元素，比较适合底层调用，
// 一般使用Arrays.copyOf完成复制数组
int[] src = {1, 2, 3};
int[] dest = new int[3];// dest 当前是 {0,0,0}
//1. 主要是搞清楚这五个参数的含义
//2.
// 源数组
// * @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);//这句话的含义是，从src数组下标为0开始，拷贝到dest数组中下为0开始的位置，拷贝的长度是src.length();
//第一个参数的含义是拷贝的原数组
//第二个参数的含义是从原数组的第几个下标开始拷贝
//第三个参数的含义是拷贝的那个数组去。就是把原数组拷贝到一个新的数组
//第四个参数的含义是从新数组的那个下标开始接收原数组拷贝的内容
//第五个参数的含义是，要拷贝的长度是多少
// int[] src={1,2,3};
System.out.println("dest=" + Arrays.toString(dest));//[1, 2, 3]
//currentTimeMillens:返回当前时间距离1970-1-1 的毫秒数
System.out.println(System.currentTimeMillis());
}
}
Biglnteger和BigDecimal类
BigInteger和BigDecimal介绍
应用场景：
1)BigInteger适合保存比较大的整型
2)BigDecimal适合保存精度更高的浮点型(小数)
Biglnteger和BigDecimal常见方法
-
add加
-
subtract减
-
multiply乘
-
divide除
代码演示：
注意：在对 BigInteger 进行加减乘除的时候，需要使用对应的方法，不能直接进行 + - * /
package idea.chapter13.bignum;
import java.math.BigInteger;
public class BigInteger_ {
public static void main(String[] args) {
//当我们编程中，需要处理很大的整数，long 不够用
//可以使用BigInteger的类来搞定
// long l = 23788888899999999999999999999l;
// System.out.println("l=" + l);
BigInteger bigInteger = new BigInteger("23788888899999999999999999999");
BigInteger bigInteger2 = new BigInteger("1009999999999999999999999999999999999999999999999999999999");
System.out.println(bigInteger);
//1. 在对 BigInteger 进行加减乘除的时候，需要使用对应的方法，不能直接进行 + - * /
//2. 可以创建一个 要操作的 BigInteger 然后进行相应操作
BigInteger add = bigInteger.add(bigInteger2);
System.out.println(add);//加
BigInteger subtract = bigInteger.subtract(bigInteger2);
System.out.println(subtract);//减
BigInteger multiply = bigInteger.multiply(bigInteger2);
System.out.println(multiply);//乘
BigInteger divide = bigInteger.divide(bigInteger2);
System.out.println(divide);//除
}
}代码演示：
注意： 如果对 BigDecimal进行运算，比如加减乘除，也需要使用对应的方法
package idea.chapter13.bignum;
import java.math.BigDecimal;
public class BigDecimal_ {
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
//如果有无限循环小数，就会保留 分子 的精度
System.out.println(bigDecimal.divide(bigDecimal2, BigDecimal.ROUND_CEILING));
}
}
小结
1.在对 BigInteger 进行加减乘除的时候，需要使用对应的方法，不能直接进行 + - * /
2.可以创建一个 要操作的 BigInteger 然后进行相应操作
3.如果对 BigDecimal进行运算，比如加减乘除，需要使用对应的方法
4.创建一个需要操作的 BigDecimal 然后调用相应的方法即可
5.在进行除法的时候可能会抛出异常ArithmeticException（只需在调用divide 方法时，指定精度即可 就是增加一个BigDecimal.ROUND_CEILING）
扫一扫
522
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
