对于常见API的学习，主要学习了关于时间和日期的传统和新增APi
目录
1.Math
2.System
3.Runtime
4.日期和时间
（1）JDK8前传统时间API
[1] Date
[2] SimpledateFormat
[3]Calendar
（2）JDK8后新增时间API
[1]代替Calendar
[2]代替Date
[3]代替SimpleDateFormat
[4]其他补充
5.Arrays
6.*Lambda 表达式
7.方法引用（略）
1.Math
代表数学，一个工具类，提供一些对数据操作的静态方法
常用方法
| 方法名 | 说明 |
| public static int abs(int a) | 获取参数绝对值 |
| poublic static double ceil(double a) | 向上取整 |
| public static double floor(double a) | 向下取整 |
| public static int round(float a) | 四舍五入 |
| public static int max(int a,int b) | 获取两个int值中的较大值 |
| public static double pow(double a,double b) | 返回a 的b次幂的值 |
| public static double random() | 返回值为double的随机值，范围为[0.0.,1.0] |
package API_2;
public class Text {
public static void main(String[] args) {
//目标：了解Math类的常见方法
//1.public static int abs(int a) 获取参数绝对值(返回一定是正数)
System.out.println(Math.abs(-12));
System.out.println(Math.abs(-3.14));
//2.public static double ceil(double a) 向上取整
System.out.println(Math.ceil(4.00001));
System.out.println(Math.ceil(4.0));
//3.public static double floor(double a) 向下取整
System.out.println(Math.floor(4.99999));
//4.public static int round(float a) 四舍五入
System.out.println(Math.round(3.4999));
//5.public static int max(int a,int b) 获取两个int值中的较大值
// public static int min(int a,int b)
System.out.println(Math.max(10, 20));
System.out.println(Math.min(10, 20));
//6.public static double pow(double a,double b) 返回a 的b次幂的值
System.out.println(Math.pow(2, 3));
//7.public static double random() 返回值为double的随机值，范围为[0.0.,1.0]
System.out.println(Math.random());
}
}
2.System
代表系统所在的系统，也是一个工具类
常见方法
| 方法名 | 说明 |
| public static void exit(int status) | 终止当前运行的java虚拟机 |
| public static long currentTimeMillis() | 返回当前系统的时间毫秒形式 |
package API_2;
public class Text1 {
public static void main(String[] args) {
//目标：了解System类的常见方法
//1.public static void exit(int status) 终止当前运行的java虚拟机
//该参数作用状态；按照惯例，非零状态码表示异常终止
//System.exit(0); //一般不必使用
System.out.println("---------");
//2.public static long currentTimeMillis() 返回当前系统的时间毫秒形式
long time = System.currentTimeMillis();
//测试程序执行时间
for (int i = 0; i < 1000000; i++) {
System.out.println("输出了"+i);
}
long time1 = System.currentTimeMillis();
System.out.println("运行时间:"+(time1-time)/1000.0+"S");
}
}
3.Runtime
代表程序的运行环境，是一个单例类
package API_2;
import java.io.IOException;
public class Text2 {
public static void main(String[] args) throws IOException, InterruptedException {
//目标“了解Runtime的用法
//1.返回与当前java应用程序关联的运行时对象
Runtime r = Runtime.getRuntime();
//2.终止当前运行的的虚拟机 exit() 终止异常
//3.public int availableProcessors;获取虚拟机能够使用的处理器数
System.out.println(r.availableProcessors());
//4.public long totalMemory() 返回java虚拟机中的可用内存
System.out.println(r.totalMemory() /1024.0/1024.0+"MB");
//5.public long freeMemory()返回java虚拟机中的可用内存
System.out.println(r.freeMemory()/1024.0/1024.0+"MB");
//6.public Process exec(String command)启动某个程序 并返回代表该程序的对象
// r.exec("C:\\Users\\22935\\AppData\\Local\\Programs\\Xmind\\Xmind.exe");
Process p = r.exec("QQ");
Thread.sleep(5000);
p.destroy();
}
}
4.BigDecimal
用于解决浮点型运算时，出现结果失真的问题
运算失真：
常用构造器
| 构造器 | 说明 |
| public BigDecimal (double val)不推荐使用 | 将double转换为BigEecimal |
| public BigDecimal (String val) | 将String转换为BigDecimal |
常用方法
| 方法名 | 说明 |
| public static BigDecimal valueof(double val) | 转换一个double成BigDecimal |
| public BigDecima add(BigDecima b) | 加法 |
| public BigDecima subtract (BigDecima b) | 减法 |
| public BigDecima multiply (BigDecima b) | 乘法 |
| public BigDecima divde (BigDecima b) | 除法 |
| public BigDecima divide (BigDecima b )（另一个BigDecimal对象，精确几位，舍入模式） | 除法 可以控制到小数点后几位 |
| public double doubleValue() | 将BigDecimal转换为double |
package API_2;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.RoundingMode;
public class Text3 {
public static void main(String[] args) {
double a= 0.1;
double b= 0.2;
double c= a+b;
System.out.println(c);
//1.把他变成字符串封装成BigDecimal的对象来运算
//BigDecimal a1 = new BigDecimal(Double.toString(a));
//BigDecimal b1 = new BigDecimal(Double.toString(b));
//推荐以下方式 把小数转换为BigDecimal对象来使用
BigDecimal a1 = BigDecimal.valueOf(a);
BigDecimal b1 = BigDecimal.valueOf(b);
BigDecimal c1 = a1.add(b1); //加法
//BigDecimal c1 = a1.subtract(b1); //减法
//BigDecimal c1 = a1.multiply(b1); //乘法
//BigDecimal c1 = a1.divide(b1); //除法
System.out.println(c1);
BigDecimal i = BigDecimal.valueOf(0.1);
BigDecimal j = BigDecimal.valueOf(0.3);
BigDecimal k = i.divide(j,2, RoundingMode.HALF_UP);
k.doubleValue(); //转换为double返回
System.out.println(k);
}
}
4.日期和时间
（1）JDK8前传统时间API
[1] Date
代表的是时间和日期
常用构造器
| 构造器 | 说明 |
| public Date() | 创建一个Date对象，代表的是系统当前此刻日期时间 |
| public Date(long time) | 把时间毫秒值转换为Date日期对象 |
常用方法
| 常见方法 | 说明 |
| public long getTime() | 返回从1970年1月1日 00:00：00走到此刻的总毫秒数 |
| public void setTime(long time) | 设置日期对象的时间为当前时间毫秒值对应的时间 |
package API_2;
import java.util.Date;
public class Time {
public static void main(String[] args) {
//目标：掌握Date日期类的使用
//1.创建一个Date的对象，代表系统当前时间信息的
Date d = new Date();
System.out.println(d);
//2.拿到时间毫秒值
long time = d.getTime();
//3.时间毫秒值转换为日期对象 2S后的时间是多久
time += 2000;
Date d2 = new Date(time);
System.out.println(d2);
//4.直接把日期对象的时间通过setTime方法进行修改
Date d3 = new Date();
d3.setTime(time);
System.out.println(d3);
}
}
[2] SimpledateFormat
简单日期格式化，可以用来把日期对象，时间毫秒值格式化成我们想要的形式
常见构造器
| 常见构造器 | 说明 |
| public SimpleDateFormat(String patterrn) | 创建简单日期格式化对象，并封装时间等待格式 |
常用方法
| 格式化时间的方法 | 说明 |
| public final String format (Date date) | 将日期格式化成日期/时间字符串 |
| public final String format(Object time) | 将时间毫秒值化成日期/时间字符串 |
| public Date parse(String source) | 把字符串解析成日期对象 |
package API_2;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Time1 {
public static void main(String[] args) throws ParseException {
//目标：掌握SimpletDateFormat
//1.准备时间
Date d = new Date();
System.out.println(d);
long time = d.getTime();
System.out.println(time);
//2.格式化日期对象和时间毫秒值
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss EEE a"); //年 月 日 时 分 秒 星期几 上下午
String t = sdf.format(time);
System.out.println(t);
//3.SimpDateFormat解析字符串成为日期对象
String dateStr = "2023-04-17 17:23:00";
//1.创建简单日期格式化对象,指定的时间格式必须与被解析的时间格式一模一样，否则程序会出bug
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date d2 = sdf2.parse(dateStr);
System.out.println(d2);
}
}
[3]Calendar
（抽象类）代表的是系统此刻对应的日历，通过它可以单独获取，修改时间中的年月日时分秒等。
常用方法
| 方法名 | 说明 |
| public static Calendar getInstance() | 获取当前日历对象 |
| public int get(int field) | 获取日历中的某个信息 |
| public final Date getTime() | 获取日期对象 |
| public long getTimeInMillis() | 获取时间毫秒值 |
| public void set(int field,int value) | 修改日历的某个信息 |
| public void add(int field,int amount) | 为某个信息增加/减少指定的值 |
package API_2;
import java.util.Calendar;
import java.util.Date;
public class Time3 {
public static void main(String[] args) {
//目标：掌握Calendar的使用和特点
//1.得到系统此刻时间对应的日历对象
Calendar now = Calendar.getInstance();
System.out.println(now);
//2.获取日历中的某个信息
int year = now.get(Calendar.YEAR);
System.out.println(year);
//通过字段信息获取信息
//3.拿到日历中记录的日期对象
Date d = now.getTime();
System.out.println(d);
//4。拿到时间对象的时间毫秒值
long time = now.getTimeInMillis();
System.out.println(time);
//5.修改日历中的某个信息
now.set(Calendar.MONTH,4);//月份是从0开始
System.out.println(now);
//6.为某个信息增加或者减少多少
now.add(Calendar.DAY_OF_YEAR,100);
now.add(Calendar.DAY_OF_YEAR,-100);
}
}
（2）JDK8后新增时间API
传统时间API的不足
- 设计不合理，使用不合理，很多都淘汰了
- 都是可变对象，修改后会丢失最开始的时间信息
- 线程不安全
- 只能精确到毫秒
[1]代替Calendar
LocalDate: 代表本地日期（年月日，星期）
LocalTime:代表本地时间（时分秒，纳秒）
LocalDateTime:代表本地日期，时间（年月日，星期，时，分，秒）
| 方法名 | 示例 |
| public static Xxxx now();获取系统当前时间对应的对象 | LocaDate ld = LocalDate.now(); LocalTime lt = LocalTime.now(); LocalDateTime ldt = LoacDateTime.now(); |
常用方法
| 方法名 | 说明 |
| public int getYear() | 获取年 |
| public int getMonthValue() | 获取月份（1-12） |
| public int getDayofMonth() | 获取日 |
| public int getDayofYear() | 获取当前是一年中的第几天 |
| public DayOfWeek getDayOfWeek() | 获取星期几;ld.getDayoOfWeek().getValue() |
| 方法名 | 说明 |
| withYear,withMonth,withDayofMonth,withDayOfYear | 直接修改某个信息，返回新日期对象 |
| piusYears,plusMonths,plusDays,plusWeeks | 把某个信息加多少，返回新日期对象 |
| minusYears,minusMonths,minusDays | 把某个信息减多少，返回新日期对象 |
| equals,isBeffore,isAfter | 判断两个日期对象，是否相等，在前还是在后 |
package API_2;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
public class Time4 {
public static void main(String[] args) {
//0.获取日期对象中的信息
LocalDate ld = LocalDate.now(); // 年 月 日
LocalTime lt = LocalTime.now(); // 时 分 秒 纳秒 不可变的 //基本用法与LocalDate是基本一致的
LocalDateTime ldt = LocalDateTime.now(); //上述的信息都有，
//1. 获取日期对象中的信息
int year = ld.getYear(); //年
int month = ld.getMonthValue();//月
int day = ld.getDayOfMonth(); //日
int dayOfYear = ld.getDayOfYear();//一年中的第几天
int dayOfWeek = ld.getDayOfWeek().getValue(); //星期几
//2.直接修改某个信息 withYear withMonth withDayOfMonth withDayOfYear
// 修改后可以返回一个新的日期对象
LocalDate ld2 = ld.withYear(2099);
LocalDate ld3 = ld.withMonth(12);
//3.把某个信息加多少 ：plusYears plusMonths plusDays plusWeeks
//修改后可以返回一个新的日期对象
LocalDate ld4 = ld.plusYears(2);
LocalDate ld5 = ld.plusMonths(3);
//4.把某个信息减多少：minusYears minusMonths minusDays minusWeeks
LocalDate ld6 = ld.minusYears(1);
LocalDate ld7 = ld.minusMonths(5);
//5.获取指定日期的LocalDate对象 ：public static LocalDate of(int year,int month,int ady)
LocalDate ld8 = LocalDate.of(2023, 4, 17);
//6.判断两个日期对象 是否相等 在前还是在后 equals isBefore isAfter
System.out.println(ld6.equals(ld));
System.out.println(ld6.isBefore(ld));
System.out.println(ld6.isAfter(ld));
//*7.可以把LocalDateTime转换成LocalDate和LocalTime
LocalDate ld9 = ldt.toLocalDate();
LocalTime lt1 = ldt.toLocalTime();
//也可以合并
LocalDateTime ldt1 = LocalDateTime.of(ld9,lt1);
}
}
ZoneId：时区
ZonedDateTime ：带时区的时间
package API_2;
import java.time.Clock;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.util.Calendar;
import java.util.TimeZone;
public class Time5 {
public static void main(String[] args) {
//目标：了解时区和带时区的时间
//1.ZoneI的常见方法
//public static ZoneId systemDefault(); 获取系统默认的时区
ZoneId zoneId = ZoneId.systemDefault();
System.out.println(zoneId.getId());
System.out.println(zoneId);
System.out.println(zoneId.toString());
//public static Set<String> getAvailableZoneIds; 获取java支持的全部时区
System.out.println(ZoneId.getAvailableZoneIds());
//public static ZoneId of(String zoneId):把某个时区id封装成ZoneId对象
ZoneId zone = zoneId.of("America/New_York");
//2.ZoneDateTime 带时区的时间
//public static ZoneDateTime now (ZoneId Zone);获取某个时区的ZonedDateTime对象
ZonedDateTime now = ZonedDateTime.now(zoneId);
System.out.println(now);
ZonedDateTime now1 = ZonedDateTime.now(Clock.systemUTC());
System.out.println(now1);
//public static ZoneDateTime now();；获取系统默认时区的ZonedDateTime对象
ZonedDateTime now2 = ZonedDateTime.now();
System.out.println(now2);
Calendar.getInstance(TimeZone.getTimeZone(zoneId));
}
}
ZoneId常用方法
| 方法名 | 说明 |
| public static set<String> getAvailableZoneIds() | 获取java中支持的所有时区 |
| public static zoneld systemDefault() | 获取系统默认时区 |
| public static Zoeld of(String zoneld) | 获取一个指定时区 |
ZonedDateTime常用方法
| 方法名 | 说明 |
| public static ZonedDateTime | 获取当前时区的ZonedateTime对象 |
| public static ZoneddDateTime now(Zoneld zone) | 获取指定时区的ZonedDateTime对象 |
| getYear getMonthValue | 获取年月日，时分秒，纳秒等 |
| public ZonedDateTime withXxx(时间) | 修改时间系列的方法 |
| public ZoneDateTime minusXxx(时间) | 减少时间系列的方法 |
| public ZoneDateTime plusXxx(时间) | 增加时间系列的方法 |
[2]代替Date
Instant：时间线上的某个时刻/时间戳
| 方法名 | 说明 |
| public static Instant now() | 获取当前时间的Instant对象（标准时间） |
| public long getEpochSecond() | 获取从1970-01-01T00:00开始记录的秒数 |
| public int getNano() | 从时间线开始，获取从第二个的纳秒数 |
| plusMilis plusSconds plsuNanos | 判断系列的方法 |
| minusMillis minnsSconds minusNanos | 减少时间系列的方法 |
| equals isBefore isAfter | 增加时间系列的方法 |
package API_2;
import java.time.Instant;
public class Text6 {
public static void main(String[] args) {
//1.创建Instant的对象 获取此刻的时间信息
Instant now = Instant.now();
//2.获取总秒数
long second = now.getEpochSecond();
System.out.println(second);
//3.不到1秒的纳秒数
int nano = now.getNano();
System.out.println(nano);
//4.加法功能
Instant i = now.plusNanos(111);
Instant j = now.minusNanos(11);
//Instant对象的作用：做代码的性能分析，或者记录用户操作的时间点
Instant now1 = Instant.now();
//代码执行
Instant now2 = Instant.now();
}
}
[3]代替SimpleDateFormat
DateTimeFormatter:格式化器，用于时间的格式化，解析（线程安全）
| 方法名 | 说明 |
| public static DateTimeFormatter ofpattter(时间格式) | 获取格式器对象 |
| public String fornat(时间对象) | 格式化时间 |
LocaDateTime提供的格式化，解析时间的方法
方法名 说明 public String format(DateTimeFormatter formatter) 格式化时间 public static LocalDateTime parse(CharSequence text,DateTimeFormatter formatter) 解析时间
[4]其他补充
Period :计算日期间隔（年，月，日，用于计算两个LocalDate对象的相差年数，月数，天数
Duration:计算时间间隔（时，分，秒，纳秒）支持LocalTime LocalDateTime Instant
Period常用方法
| 方法名 | 说明 |
| Public static Period between(LocalDate start,LocalDate end) | 传入2个日期对象，得到Period对象 |
| public int getYears() | 计算隔几年，并返回 |
| public int getMonths() | 计算隔几个月，并返回 |
| public int getDays() | 计算隔多少天，并返回 |
package API_2;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.Period;
public class Time6 {
public static void main(String[] args) {
//目标：掌握Period的用法
LocalDate start = LocalDate.of(2023,4,17);
LocalDate end = LocalDate.of(2024,8,6);
//1.创建period对象 ，封装两个日期对象
Period period = Period.between(start,end);
//2.通过period对象获取两个日期对象相差的信息
System.out.println(period.getYears());
System.out.println(period.getMonths());
System.out.println(period.getDays());
}
}
Duration常用方法
| 方法名 | 说明 |
| public static Duration between(start,end) | 传入2个时间对象，得到Duration对象 |
| public long toDays() | 计算隔多少天，并返回 |
| public long toHours() | 计算隔多少小时，并返回 |
| public long toMinutes() | 计算隔多少分，并返回 |
| public long toSeconds() | 计算隔多少秒，并返回 |
| public long toMillis() | 计算隔多少毫秒，并返回 |
| public long toNanos() | 计算隔多少纳秒，并返回 |
package API_2;
import java.time.Duration;
import java.time.LocalDateTime;
public class Time7 {
public static void main(String[] args) {
//1.得到Duration对象
LocalDateTime start = LocalDateTime.of(2024,9,22,11,11,11,11);
LocalDateTime end = LocalDateTime.of(2024,9,22,15,10,0,1);
Duration duration = Duration.between(start,end);
//2.获取两个时间对象间隔的信息
System.out.println(duration.toDays());
System.out.println(duration.toHours());
System.out.println(duration.toMillis()); //毫秒
}
}
5.Arrays
Arrays 用来操作数组的一个工具类
常用方法
| 方法名 | 说明 |
| public static String toString(类型[ ] arr) | 返回数组的内容 |
| public static int [] copyOfRange(类型[] arr,起始索引，结束索引) | 拷贝数组（指定范围） |
| public static opyOf(类型[] arr, int newLength) | 拷贝数组 |
| public static setAll(double [] array,intToDoubleFunction generator ) | 把数组的原数据改为新数据 |
| public static void sort(类型 [] arr) | 对数组进行排序（默认是升序） |
package API_2;
import java.util.Arrays;
import java.util.function.IntToDoubleFunction;
public class ArraysText {
public static void main(String[] args) {
//public static String toString(类型[ ] arr) 返回数组的内容
int[] arr = {1,2,3,4,5};
String rs = Arrays.toString(arr);
System.out.println(rs);
//public static int [] copyOfRange(类型[] arr,起始索引，结束索引) 拷贝数组（指定范围 包前不包后）
int[] arr1 = Arrays.copyOfRange(arr,0,2);
System.out.println(Arrays.toString(arr1));
//public static copyOf(类型[] arr, int newLength) 拷贝数组
// (可以指定新数组的长度 如果新数组长度小于原数组长度 则会截取)
int[] arr2 = Arrays.copyOf(arr,10);
System.out.println(Arrays.toString(arr2));
//public static setAll(double [] array,int ToDoubleFunction generator ) 把数组的原数据都改为新数据
double[] score = {100.0,80.0,46.0,56.0,85.5};
Arrays.setAll(score, new IntToDoubleFunction() {
@Override
public double applyAsDouble(int value) {
return score[value] * 0.8; //浮点数精度错误
}
});
System.out.println(Arrays.toString(score));
//public static void sort(类型 [] arr) 对数组进行排序（默认是升序）
int[] arr3 = {10,9,8,7,6,5,4,3,1,2};
System.out.println(Arrays.toString(arr3));
Arrays.sort(arr3);
System.out.println(Arrays.toString(arr3));
}
}
数组中存储的是对象，怎么进行排序？
方式一：让对象的类实现Comparable（比较规则）接口，然后重写compareTo方法，自己制定比较规则。
方式二：使用sort方法，创建Comparatorr比较器的匿名内部类对象，然后自己制定比较规则。
package API_2;
public class Student implements Comparable<Student>{
private String name;
private double high;
private int age;
public Student() {
}
public Student(String name, double high, int age) {
this.name = name;
this.high = high;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getHigh() {
return high;
}
public void setHigh(double high) {
this.high = high;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
//指定比较规则
@Override
public int compareTo(Student o) {
//约定 1 ：左边大于右边 返回正整数
//预定 2 ：小于 负整数
//约定 3 ：等于 0
//按照年龄升序排序
//if(this.age > o.age){return 1;}
//else if (this.age <o.age) {return -1;}
// return 0;
return this.age - o.age;
}
public String toString(Student o){
return "name = "+ o.getName()+"High ="+o.getHigh()+"age ="+o.getAge();
}
}
package API_2;
import java.util.Arrays;
import java.util.Comparator;
public class ArraysText1 {
public static void main(String[] args) {
//目标：掌握数组中元素的排序
Student[] students = new Student[4];
students[0] = new Student("陈平安",175.0,19);
students[1] = new Student("宁姚",170,20);
students[2] = new Student("刘羡阳",182,20);
students[3] = new Student("郑居中",180,40);
//1.对数组进行排序
// Arrays.sort(students);
// System.out.println(Arrays.toString(students));
//2.static<T> void sort(T[] arr,Comparator <? super T> c)
//排序数组
//比较规则
Arrays.sort(students, new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
//制定比较规则
//约定 1 ：左边大于右边 返回正整数
//预定 2 ：小于 负整数
//约定 3 ：等于 0
//按照年龄升序排序
/* if(o1.getHigh() > o2.getHigh()){return 1;}
else if (o1.getHigh() < o2.getHigh()) {return -1;}
return 0;
*/
return Double.compare(o1.getHigh(),o2.getHigh());
}
});
System.out.println(Arrays.toString(students));
}
}
6.*Lambda 表达式
Lambda表达式是JDK8后新增的一种语法形式，作用是简化匿名内部类的代码写法
注意：只能简化函数式接口的匿名内部类（有且只有一个抽象方法方法的接口）
package API_2;
public class Lambda {
public static void main(String[] args) {
//目标：认识Lambda 表达式
Animal a = new Animal(){
@Override
public void run(){
System.out.println("跑动");
}
};
a.run();
//Animal b = ()->{System.out.println("跑动");} b.run();
// 报错 简化只能简化函数式接口的匿名内部类接口 只有一个抽象方法的
Swimming s = ()->{
System.out.println("开始游泳");
};
}
}
interface Swimming{
void swim();
}
abstract class Animal{
public abstract void run();
}
简化规则
- 参数类型可以省略不写。
- 如果只有一个参数，参数类型可以省略。同时()也可以省略.
- 如果Lambda的表达式的方法体代码只有一行代码,可以省略大括号不写，同时要省略分号! 此时如果这行代码是return语句，也必须去掉return不写。
Arrays.setAll(score, new IntToDoubleFunction() {
@Override
public double applyAsDouble(int value) {
return score[value] * 0.8; //浮点数精度错误
}
});
//简化到一行
Arrays.setAll(score,value -> score[value]*0.8);
7.方法引用（略）
静态方法的引用
实例方法的引用
特定类型方法的引用
构造器引用
![RAG私域问答场景超级详细方案(第一期方案)[1]：工业级别构建私域问答（知识处理、知识召回排序、搜索问答模块）](https://img-blog.csdnimg.cn/img_convert/6f2648ecf791ccec4b7f995c0025cb4b.png)
