Java初学笔记17
一、Math类常用方法
1.Math.abs 绝对值
int abs = Math.abs(-9);
System.out.println(abs);//9
2.Math.pow 求幂
double pow = Math.pow(2, 4);//2 的 4 次方
System.out.println(pow);//16
3.Math.ceil 向上取整
返回>=该参数的最小整数(转成double);
double ceil = Math.ceil(3.9);
System.out.println(ceil);//4.0
4.Math.floor 向下取整
返回<=该参数的最大整数(转成double)
double floor = Math.floor(4.001);
System.out.println(floor);//4.0
5.Math.round 四舍五入
等价于 Math.floor(该参数+0.5)
long round = Math.round(5.51);
System.out.println(round);//6
6.Math.sqrt 求开方
double sqrt = Math.sqrt(9.0);
System.out.println(sqrt);//3.0
7.random 求随机数
（1）random 返回的是 [ 0，1) 之间的一个随机小数
（2）获取 a-b 之间的一个随机整数,a,b 均为整数
Math.random() * (b-a )返回的就是 [ 0 , b-a)
公式就是 (int)(a + Math.random() * (b - a +1) )
8.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常用方法
1. toString 返回数组的字符串形式
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));
2. sort 排序(自然排序和定制排序)
Integer arr[] = {1, -1, 7, 0, 89};
（1）可以直接使用冒泡排序 , 也可以直接使用 Arrays 提供的 sort 方法排序
（2）因为数组是引用类型，所以通过 sort 排序后，会直接影响到 实参 arr
【1】默认排序方法
Arrays.sort(arr);
【2】定制排序
Arrays.sort(arr, new Comparator() {
@Override
public int compare(Object o1, Object o2) {
Integer i1 = (Integer) o1;
Integer i2 = (Integer) o2;
return i2 - i1;
}
});
（1）此处sort 重载，通过传入一个接口 Comparator 实现定制排序
（2）调用 定制排序 时，传入两个参数 【1】排序的数组 arr 【2】 实现了 Comparator 接口的匿名内部类 , 要求实现 compare 方法。
（3）这里体现了接口编程的方式 , 得看源码
源码分析
（1）Arrays.sort(arr, new Comparator()）
（2） 最终到 TimSort 类的 private static void binarySort(T[] a, int lo, int hi, int start, // Comparator<? super T> c)()
（3） 执行到 binarySort 方法的代码, 会根据动态绑定机制 c.compare()执行我们传入的匿名内部类的 compare ()
new Comparator() {
@Override
public int compare(Object o1, Object o2) {
Integer i1 = (Integer) o1;
Integer i2 = (Integer) o2;
return i2 - i1;
}
}
（4） public int compare(Object o1, Object o2) 返回的值>0 还是 <0会影响整个排序结果, 这就充分体现了 接口编程+动态绑定+匿名内部类的综合使用，此外底层框架和源码的使用方式，会非常常见
练习
【3】模拟定制冒泡排序
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 i1 = (Integer) o1;
int i2 = (Integer) o2;
return i2 - i1;// return i2 - i1;
}
});
System.out.println("定制排序后的情况");
System.out.println(Arrays.toString(arr));
}
//使用冒泡完成排序
public static void bubble01(int[] arr) {
int temp = 0;
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - 1 - i; j++) {
//从小到大
if (arr[j] temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
//结合冒泡 + 定制
public static void bubble02(int[] arr, Comparator c) {
int temp = 0;
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - 1 - i; j++) {
//数组排序由 c.compare(arr[j], arr[j + 1])返回的值决定
if (c.compare(arr[j], arr[j + 1]) > 0) {
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
}
3. binarySearch 通过二分搜索法进行查找
要求必须排好序
Integer[] arr = {1, 2, 90, 123, 567};
（1）使用 binarySearch 二叉查找
（2）要求该数组是有序的. 如果该数组是无序的，不能使用 binarySearch
（3）如果数组中不存在该元素，就返回 return -(low + 1); // key not found.
int index = Arrays.binarySearch(arr, 567);
System.out.println(“index=” + index);
4. copyOf 数组元素的复制
Integer[ ] newArr = Arrays.copyOf(arr,arr.length);
（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))
5. fill 数组元素的填充
Integer[ ] num = new Integer[ ]{9.3.2}；
Arrays.fill(num, 99);
使用 99 去填充 num 数组，可以理解成是替换原来的元素
6. equals 比较两个数组元素内容是否完全一致
boolean equals = Arrays.equals(arr, arr2);
（1）如果 arr 和 arr2 数组的元素一样，则方法 true
（2） 如果不是完全一样，就返回 false
7. asList 将一数组的值，转换成list
List asList = Arrays.asList(2,3,4,5,6,1);
System.out.println(“asList=” +asList);
（1）asList 方法，会将 (2,3,4,5,6,1)数据转成一个 List 集合
（2）返回的 asList 编译类型 List(接口)
（3）asList 运行类型 java.util.Arrays#ArrayList, 是 Arrays 类的静态内部类 private static class ArrayList extends AbstractList implements RandomAccess, java.io.Serializable
四、System类常用方法
1. exit 退出当前程序
（1）exit(0) 表示程序退出
（2）0 表示一个状态 , 正常的状态
2. arraycopy 复制数组元素
（1）arraycopy比较适合底层调用，一般使用Arrays.copyOf完成复制数组.
（2）arraycopy的五个参数含义
System.arraycopy(src, srcPos, dest, destPos, length)
src：源数组
srcPos：从源数组的哪个索引位置开始拷
dest : 目标数组，即把源数组的数据拷贝到哪个数组
destPos: 把源数组的数据拷贝到目标数组的哪个索引
length: 从源数组拷贝多少个数据到目标数组
3. currentTimeMillens 返回当前时间距离1970-1-1的毫秒数
4. gc 运行垃圾回收机制System.gc( );
五、BigInteger 和 BigDecimal 类
1. 应用场景
（1）Biglnteger适合保存比较大的整型
（2）BigDecimal适合保存精度更高的浮点型(小数)
2. BigInteger类
（1）当我们编程中，需要处理很大的整数，long 不够用可以使用 BigInteger 的类来搞定。
（2）举例：
报错：
long l = 23788888899999999999999999999l;
System.out.println("l=" + l);
改进：
BigInteger bigInteger = new BigInteger("23788888899999999999999999999");
BigInteger bigInteger2 = new BigInteger("1");
（3）在对 BigInteger 进行加、减、乘、除的时候，需要使用对应的方法，不能直接进行 + - * / 。可以创建一个 要操作的 BigInteger 然后进行相应操作。
（4）创建BigInteger类对象，数据要用双引号引起来
3. BigInteger类常用方法
（1）加法 add
BigInteger add = bigInteger.add(bigInteger2);
（2）减法 subtract
BigInteger subtract = bigInteger.subtract(bigInteger2);
（3）乘法 multiply
BigInteger multiply = bigInteger.multiply(bigInteger2);
（4）除法 divide
BigInteger divide = bigInteger.divide(bigInteger2);
4. BigDecimal类
（1）当我们需要保存一个精度很高的数时，double 不够用，可以使用 BigDecima
5. BigDecimal类常用方法
（1）加减乘除方法和BigInteger类一样
（2）特别注意除法，若是结果是循环，会抛出异常，此时需要指定精度，一般设置为何分子同精度。
例如：
//可能抛出异常 ArithmeticException
System.out.println(bigDecimal.divide(bigDecimal2));
//在调用 divide 方法时，指定精度即可. BigDecimal.ROUND_CEILING
//如果有无限循环小数，就会保留 分子 的精度
System.out.println(bigDecimal.divide(bigDecimal2, BigDecimal.ROUND_CEILING));
六、第一代日期类 date
1.介绍
（1）Date类：精确到毫秒，代表特定的瞬间
（2）SimpleDateFormat类：格式和解析日期的类SimpleDateFormat格式化和解析日期的具体类。它允许进行格式化(日期->文本)、解析(文本->日期)和规范化。
（3） 获取当前系统时间
（4） 这里的 Date 类是在 java.util 包
（5）默认输出的日期格式是国外的方式, 因此通常需要对格式进行转换
2. 使用方法
方法一：
Date d1 = new Date(); //获取当前系统时间
System.out.println("当前日期=" + d1);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy 年 MM 月 dd 日 hh:mm:ss E");
String format = sdf.format(d1); // format:将日期转换成指定格式的字符串
System.out.println("当前日期=" + format);
SimpleDateFormat指定相应的格式
方法二：
（1）可以把一个格式化的 String 转成对应的 Date
（2）得到 Date 仍然在输出时，还是按照国外的形式，如果希望指定格式输出，需要转换
（3）在把 String -> Date ， 使用的 sdf 格式需要和给的 String 的格式一样，否则会抛出转换异常
String s = "1996 年 01 月 01 日 10:20:30 星期一";
Date parse = sdf.parse(s);
System.out.println("parse=" + sdf.format(parse))
方法三：
Date d2 = new Date(9234567); //通过指定毫秒数得到时间
System.out.println("d2=" + d2);
七、第二代日期类 Calenda类
1. 介绍
（1）Calendar类 是一个抽象类， 并且构造器是 private
（2）可以通过 getInstance() 来获取实例
（3）提供大量的方法和字段提供给程序员
（4）Calendar 没有提供对应的格式化的类，因此需要程序员自己组合来输出(灵活)
（5）如果我们需要按照 24 小时进制来获取时间， Calendar.HOUR 改成：Calendar.HOUR_OF_DAY
2. 使用方法
//创建日历类对象
Calendar c = Calendar.getInstance();
System.out.println("c=" + c);
//获取日历对象的某个日历字段
System.out.println("年：" + c.get(Calendar.YEAR));
// 这里为什么要 + 1, 因为 Calendar 返回月时候，是按照 0 开始编号
System.out.println("月：" + (c.get(Calendar.MONTH) + 1));
System.out.println("日：" + c.get(Calendar.DAY_OF_MONTH));
System.out.println("小时：" + c.get(Calendar.HOUR));
System.out.println("分钟：" + c.get(Calendar.MINUTE));
System.out.println("秒：" + c.get(Calendar.SECOND));
//Calender 没有专门的格式化方法，所以需要程序员自己来组合显示
System.out.println(c.get(Calendar.YEAR) + "-" + (c.get(Calendar.MONTH) + 1) + "-" +
c.get(Calendar.DAY_OF_MONTH) +
" " + c.get(Calendar.HOUR_OF_DAY) + ":" + c.get(Calendar.MINUTE) + ":" + c.get(Calendar.SECOND) );
八、第三代日期类
1.介绍
（1）JDK8加入
（2）前面两代日期类的不足分析：
JDK 1.0中包含了一个java.util.Date类，但是它的大多数方法已经在JDK 1.1引入Calendar类之后被弃用了。而Calendar也存在问题是:
【1】可变性：像日期和时间这样的类应该是不可变的。
【2】偏移性：Date中的年份是从1900开始的，而月份都从0开始。
【3】格式化：格式化只对Date有用，Calendar则不行
【4】此外，它们也不是线程安全的；不能处理闰秒等(每隔2天,多出1s).
2.LocalDate类(日期)、LocalTime类(时间)、LocalDateTime类(日期时间)
（1）LocalDate(日期/年月日)：LocalDate只包含日期,可以获取日期字段
（2）LocalTime(时间/时分秒)：LocalTime只包含时间，可以获取时间字段
（3）LocaIDateTime(日期时间/年月日时分秒)：LocalDateTime包含日期+时间，可以获取日期和时间字段
举例：
使用 now() 返回表示当前日期时间的 对象
LocalDateTime ldt = LocalDateTime.now(); //获取年月日时分秒
LocalDate now = LocalDate.now(); //可以获取年月日
LocalTime now2 = LocalTime.now();//获取到时分秒
System.out.println(ldt);
System.out.println("年=" + ldt.getYear());
System.out.println("月=" + ldt.getMonth());
System.out.println("月=" + ldt.getMonthValue());
System.out.println("日=" + ldt.getDayOfMonth());
System.out.println("时=" + ldt.getHour());
System.out.println("分=" + ldt.getMinute());
System.out.println("秒=" + ldt.getSecond())
3.DateTimeFormatter 格式日期类
（1）使用 now() 返回表示当前年月日时分秒
LocalDateTime ldt = LocalDateTime.now();
（2）使用 DateTimeFormatter 对象来进行格式化
DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String format = dateTimeFormatter.format(ldt);
System.out.println("格式化的日期=" + format)
4. Instant 时间戳类
（1）通过 静态方法 now() 获取表示当前时间戳的对象
Instant now = Instant.now();
System.out.println(now);
（2）通过 from 可以把 Instant 转成 Date
Date date = Date.from(now);
（3）通过 date 的 toInstant() 可以把 date 转成 Instant 对象
Instant instant = date.toInstant()
5.第三代日期类更多方法
（1）LocalDateTime类
（2）MonthDay类:检查重复事件是否是闰年
（3）增加日期的某个部分
（4）使用plus方法测试增加时间的某个部分
提供 plus 和 minus 方法可以对当前时间进行加或者减
看看 890 天后，是什么时候 把 年月日-时分秒
LocalDateTime localDateTime = ldt.plusDays(890);
System.out.println("890 天后=" + dateTimeFormatter.format(localDateTime));
（5）使用minus方法测试查看一年前和一年后的日期
看看在 3456 分钟前是什么时候，把 年月日-时分秒输出
LocalDateTime localDateTime2 = ldt.minusMinutes(3456);
System.out.println("3456 分钟前 日期=" + dateTimeFormatter.format(localDateTime2));
九、关于字符串，异常的练习题
练习1：
练习2：
练习3
练习3改进：
练习4
练习5
93
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
