API概述
API全称Application Programming interface，意为应用程序编程接口。API就是Java中已经写好的类方法等可以直接拿来解决问题，提高开发效率。
| 常用API | ||||
| Object | LocalTime | Set | File0utputStream | Properties |
| Objects | LocalDateTime | HashSet | Reader | Thread |
| Integer | Duration | LinkedHashSet | FileReader | Runnable |
| StringBuilder | Period | TreeSet | Writer | Callable |
| StringBuffer | ZoneId | Map | FileWriter | ExecutorService |
| Math | ZonedDateTime | HashMap | BufferdInputStream | ThreadPoolExecutor |
| System | Arrays | LinkedHashMap | Bufferd0utputStream | Socket |
| Runtime | Comparable | TreeMap | BufferedReader | ServerSocket |
| BigDecimal | Comparator | Iterator | BufferedWriter | Class |
| Date | Collection | Stream | PrintStream | Method |
| SimpleDateFormat | List | InputStream | PrintWriter | Constructor |
| Calendar | ArrayList | FileInputStream | 0bjectInputStream | Field |
| LocalDate | LinkedList | OutputStream | ObjectOutputStream | Proxy |
Object
- Object类是ava中所有类的祖宗类，因此，Java中 所有类的对象都可以直接使用Object类中提供的一些方法。
常用方法
| 变量和类型 | 方法 | |
| 1. | protected Object | clone() |
| 2. | boolen | equals(Object obj) |
| 3. | String | toString() |
方法说明
1.创建并返回此对象的副本，即用来克隆（使用时子类要重写该方法且要实现一个空接口Cloneable，该接口是标记接口）
clone分为浅克隆和深克隆
浅克隆：拷贝出的新对象，与原对象中的数据一模一样(引用类型拷贝的只是地址)
深克隆：对象中基本类型的数据直接拷贝。对象中的字符串数据拷贝的还是地址。对象中还包含的其他对象，不会拷贝地址，会创建新对象。（默认为浅克隆，需要自己重写clone方法实现深克隆）
2.指示某个其他对象是否“等于”此对象。（默认比较地址是否相同，用时一般要重写以便自己制定比较规则）
3.返回对象的字符串表示形式。
Objects
概述
Objects是一个工具类，提供了很多操作对象的静态方法给我们使用。
常用方法
| 变量和类型 | 方法 | |
| 1. | public static boolean | equals(Object a, object b) |
| 2. | public static boolean | isNull(Object obj ) |
| 3. | public static boolean | nonNull(Object obj) |
方法说明
- 先做非空判断， 再比较两个对象（两个对象都可以为null）
- 判断对象是否为null，为null返回true， 反之返回false（与直接用 == 一样）
- 判断对象是否不为nu1l，不为nu11则返回true，反之返回false
包装类
概述
基本类型的数据不是对象，包装类就是把基本数据类型的数据包装成对象。
| 基本数据类型 | 对应的包装类(引用数据类型) |
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| char | Character |
| float | Float |
| Double | Double |
| boolean | Boolean |
常用方法
包装方法
| 变量和类型 | 方法 | 备注 |
| public | Integer(int value) | 已过时（不要使用） |
| public static | Integer valueOf(int i) | 可以使用 |
public class Time {
public static void main(String[] args) {
Integer a1 = Integer.valueOf(1);
System.out.println(a1);
//其他数据类型的包装与此类似
}
}补充
Java中有自动装箱和自动拆箱功能
- 自动装箱：可以自动把基本类型的数据转换成对象。
- 自动拆箱：可以自动把包装类型的对象转换成对应的基本数据类型。
// 自动装箱
Integer a1 = 1;
// 自动拆箱
int a2 = a1;其他常用操作
- 可以把基本类型的数据转换成字符串类型。
| 变量和类型 | 方法 |
| public static String | toString(double d) |
| public String | toString() |
- 可以把字符串类型的数值转换成数值本身对应的数据类型。（小数不能直接转成整型）
| 变量和类型 | 方法 |
| public static int | parselnt(String s) |
| public static Integer | valueOf(String s) |
String A = "1";
int a = Interger.parseInt();
//其他数据类型的转换与此类似StringBuilder与StringBuffer
StringBuilder
概述
StringBuilder代表可变字符串对象，相当于是一个容器，它里面装的字符串是可以改变的，就是用来操作字符串的。
| 构造器 | 说明 |
| public StringBuilder() | 创建一个空白的可变的字符串对象，不包含任何内容 |
| public StringBuilder(String str) | 创建一个指定字符串内容的可变字符串对象 |
常用方法
| 变量和类型 | 方法 | |
| 1. | public StringBuilder | append(任意类型) |
| 2. | public StringBuilder | reverse() |
| 3. | public int | length() |
| 4. | public String | toString( ) |
- 拼接内容，可以添加任意数据类型并返回StringBuilder对象本身
- 将对象的内容反转
- 返回对象内容长度
- 通过toString( )就可以实现把StringBuilder转换为String
用StringBuilder的原因
StringBuilder比String更适合做字符串的修改操作，效率会更高，代码也会更简洁。String为不可变字符串，操作起来会很慢。对于字符串相关的操作， 如频繁的拼接、修改等，更建议使用StringBuidler， 效率更高！如果操作字符串较少，或者不需要操作，以及定义字符串变量，还是建议用String。
StringBuffer
StringBuffer的用法与StringBuilder一样。但StringBuilder是线程不安全的StringBuffer是线程安全的。（很多用户一起使用StringBuilder会出bug，但是StringBuffer不会有问题）
StringJoiner
概述
●JDK8开始才有，跟StringBuilder一样，也是用来操作字符串的，也可以看成是一个容器,创建之后里面的内容是可变的。●好处：不仅能提高字符串的操作效率，并且在有些场景下使用它操作字符串，代码比StringBuilder更简洁
| 构造器 | 说明 |
| public StringJoiner (间隔符号) | 创建一个stringJoiner对象， 指定拼接时的间隔符号 |
| public stringJoiner (间隔符号，开始符号，结束符号) | 创建个StringJoiner对象， 指定拼接时的间隔符号、开始符号、结束符号 |
方法
| 变量和类型 | 方法 | |
| 1. | public StringJoiner | add (添加的内容) |
| 2. | public int | length() |
| 3. | public String | toString() |
- 添加数据，并返回对象本身
- 返回长度(字符出现的个数)
- 返回一个字符串(该字符串就是拼接之后的结果)
Math、System、Runtime
Math
概述
Math代表数学，是一个工具类，里面提供的都是对数据进行操作的一些静态方法。
常用方法
| 变量和类型 | 方法 | 说明 |
| public static int | abs(int a) | 获取参数绝对值 |
| public 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 int | min(int a,int b) | 获取两个int值中的较小值 |
| public static double | pow(double a,double b) | 返回a的b次幂的值 |
| public static double | random( ) | 返回值为double的随机值，范围[0.0,1.0) |
System
概述
System代表程序所在的系统，也是一个工具类。
常用方法
| 变量和类型 | 方法 | |
| 1. | public static void | exit(int status) |
| 2. | public static long | currentTimeMillis() |
- 终止当前运行的Java虚拟机。该参数用作状态代码；按照惯例，非零状态代码表示异常终止。（人为的终止虚拟机）
- 取当前系统的时间。返回的是long为型的时间毫秒值：指的是从1970-1-1 0:0:0开始建到此 刻的总的毫秒值，1s = 1000ms
Runtime
概述
Runtime代表程序所在的运行环境，且是一个单例类。
常用方法
| 变量和类型 | 方法 | |
| 1. | public static Runtime | getRuntime() |
| 2. | public void | exit(int status) |
| 3. | public int | availableProcessors() |
| 4. | public long | totalMemory() |
| 5. | public long | freeMemory() |
| 6. | public Process | exec(String command) |
- 返回与当前Java应用程序关联的运行时对象
- 终止当前运行的虚拟机
- 返回Java虚拟机可用的处理器数。
- 返回Java虚拟机中的内存总量（内存单位是字节）。
- 返回Java虚拟机中的可用内存（内存单位是字节）。
- 启动某个程序，并返回代表该程序的对象
Runtime r = Runtime.getRuntime();
//运行程序，引号里的是程序的地址。
Process p = r.exec("D:\\softwaer\\QQmusic\\QQMusic.exe");
//关闭程序。
p.destroy();//BigDecimal
概述
●用于解决浮点型运算时，出现结果失真的问题。
| 构造器 | 说明 |
| public BigDecimal(double val) | 将double转换为BigDecimal，不推荐使用这个 |
| public BigDecimal(String val) | 把String转成BigDecimal |
常用方法
| 变量和类型 | 方法 | 说明 |
| public static BigDecimal | valueOf( double val) | 转换一个double成BigDecimal。 |
| public BigDecimal | add(BigDecimal b) | 加法 |
| public BigDecimal | subtract(BigDecimal b) | 减法 |
| public BigDecimal | multiply(BigDecimal b) | 乘法 |
| public BigDecimal | divide(BigDecimal b) | 除法（结果不能是循环小数，不然会报错） |
| public BigDecimal | divide (另一个BigDecimal对象， 精确几位，舍入模式) | 除法，可以控制精确到小数几位 |
| public double | doubleValue() | 将BigDecimal转换为double |
JDK8之前传统的日期、时间
Date
概述
代表的是系统当前的日期和时间。
| 构造器 | 说明 |
| public Date() | 创建一个Date对象，代表的是系统当前此刻日期时间。 |
| public Date(long time) | 把时间毫秒值转换成Date日期对象。 |
常见方法
| 变量和类型 | 方法 | 说明 |
| public long | getTime() | 返回从1970年1月1日00:00:00走到 此刻的总的毫秒数 |
| public void | setTime(long time) | 设置日期对象的时间为当前时间毫秒值对应的时间 |
SimpleDateFormat
概述
●SimpleDateFormat代表简单日期格式化，可以用来把日期对象、时间毫秒值格式化成我们想要的形式。
| 常用构造器 | 说明 |
| public SimpleDateFormat(String pattern) | 创建简单日期格式化对象，并封装时间的格式 |
SimpleDateFormat d = new SimpleDateFormat("yyyy年MM.dd HH:mm:ss")格式
| 符号 | 时间 |
| y | 年 |
| M | 月 |
| d | 天 |
| E | 周几 |
| a | 上下午 |
| H | 小时 |
| m | 分 |
| s | 秒 |
| "yyyy年MM.dd HH:mm:ss" | 2023年11.16 18:13:28 |
常用方法
| 变量和类型 | 方法 | 说明 |
| public final String | format(Date date) | 将日期格式化成日期/时间字符串 |
| public final String | format(Object time) | 将时间毫秒值式化成日期/时间字符串 |
解析方法
| 变量和类型 | 方法 | 说明 |
| public Date | parse(String source) | 把字符串时间解析成日期对象 |
创建简单日期格式化对象，指定的时间格式必须与被解析的时间格式一模一样， 否则程序会出bug。
Calendar
概述
Calendar代表的是系统此刻时间对应的日历。通过它可以单独获取、修改时间中的年、月、日、时、分、秒等。（Calendar是一个抽象类）（月是从0开始计算的）
常用方法
| 变量和类型 | 方法 | 说明 |
| 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) | 为某个信息增加/减少指dang |
- 获取日历中的某个信息时一些对应的标识
| YEAR | 年 |
| MONTH | 月（从0开始计算，要加1才是真正的月份） |
| DAY_OF_MONTH | 日 |
| DAY_OF_WEEK | 周 |
| HOUR | 时（12时制） |
| HOUR_OF_DAY | 时（24时制） |
| MINUTE | 分 |
| SECOND | 秒 |
| AM_PM | 上下午（上午为0，下午为1） |
| days | 一年中的第几天 |
当修改或添加时间超过最大限度时会进位。例如如果增加60秒相当于增加1分钟。
例子
Calendar now = Calendar.getInstance();
now.get(Calendar.DAY_OF_MONTH);
now.set(Calendar.DAY_OF_MONTH,223);//修改值
now.add(Calendar.DAY_OF_MONTH,20);//增加值，可以加负值JDK8开始新增的日期、时间
概述
传统日期、时间与新增的比较
JDK8之前传统的时间API有诸多不好之处：1、设计不合理，使用不方便，很多都被淘汰了。2、都是可变对象，修改后会丢失最开始的时间信息。3、线程不安全。4、只能精确到毫秒。
JDK8开始之后新增的时间API有诸多好处：1、设计更合理，功能丰富，使用更方便。2、都是不可变对象，修改后会返回新的时间对象，不会丢失最开始的时间。3、线程安全。4、能精确到毫秒、纳秒。（1毫秒=1000微秒，1微秒=1000纳秒）
JDK8新增的时间
| 说明 | |||
| 1. | LocalDate | 年、月、日 | 代替Calendar |
| 2. | LocalTime | 时、分、秒 | |
| 3. | LocalDateTime | 年、月、日时、分、秒 | |
| 4. | ZoneId | 时区 | |
| 5. | ZonedDateTime | 带时区的时间 | |
| 6. | Instant | 时间戳/时间线 | 代替Date |
| 7. | DateTimeFormatter | 用于时间的格式化和解析 | 代替SimpleDateFormat |
| 8. | Period | 时间间隔(年，月，日) | 其他补充 |
| 9. | Duration | 时间间隔(时、分、秒，纳秒) |
LocalDate、LocalTime、LocalDateTime
LocalDate:代表本地日期(年、月、日、星期)
LocalTime:代表本地时间(时、分、秒、纳秒)
LocalDateTime:代表本地日期、时间(年、月、8、星期、时、分、秒、纳秒)
它们获取对象的方案
| 方法名 | 实例 |
| public static Xxxx now()获取系统当前时间对应的该对象（对象为不可变对象） | LocaDate ld = LocalDate.now(); |
| LocalTime lt = LocalTime.now(); | |
| LocalDateTime ldt = LocalDateTime.now(); |
操作方法
LocalDate的常用API
都是处理年、月、日、、 星期相关的。
| 方法名 | 说明 |
| public int geYear() | 获取年 |
| public int getMonthValue() | 获取月份(1-12) |
| public int getDayOfMonth() | 获取日 |
| public int getDayOfYear() | 获取当前是一年中的第几天 |
| Public DayOfWeek getDayOfWeek() | 获取星期几：ld.getDayOfWeek().getValue() |
| withYear、withMonth、withDayOfMonth、 withDayOfYear | 直接修改某个信息， 返回新日期对象 |
| plusYears、plusMonths、 plusDays、 plusWeeks | 把某个信息加多少，返回新日期对象 |
| minusYears、minusMonths、 minusDays, minusWeeks | 把某个信息减多少，返回新日期对象 |
| equals isBefore isAfter | 判断两个日期对象，是否相等，在前还是在后 |
LocalTime的常用API
都是处理时、分、秒、纳秒相关的。
| 方法名 | 说明 |
| public int getHour() | 获取小时 |
| public int getMinute() | 获取分 |
| public int getSecond() | 获取秒 |
| public int getNano() | 获取纳秒 |
| withHour、withMinute、 withSecond、wi thNano | 修改时间，返回新时间对象 |
| plusHours、plusMinutes、plusSeconds、plusNanos | 把某个信息加多少，返回新时间对象 |
| minusHours、minusMinutes、 minusSeconds、 minusNanos | 把某个信息减多少，返回新时间对象 |
| equals isBefore isAfter | 判断2个时间对象，是否相等，在前还是在后 |
LocalDateTime的常用API
可以处理年、月、日、星期、时、分、秒、纳秒等信息。
| 方法名 | 说明 |
| getYear、getMdhthValue、getDayOfMonth getDayOfYear、getDayOfWeek、getHour getMinute、 getSecond、 getNano | 获取年月日、时分秒、纳秒等（纳秒为不到1秒的纳秒数） |
| withYear、withMonth、 withDay0fMonth withDayOfYear、withHour、withMinute withSecond、withNano | 修改某个信息，返回新日期时间对象 |
| plusYears、plusMonths、 plusDays plusWeeks、plusHours、plusMinutes plusSeconds、 plusNanos | 把某个信息加多少，返回新日期时间对象 |
| minusYears、minusMonths、minusDays minusWeeks、minusHours、minusMinutes minusSeconds、 minusNanos | 把某个信息减多少，返回新日期时间对象 |
| equals isBefore isAfter | 判断2个时间对象，是否相等，在前还是在后 |
例子
LocalDate d1 = LocalDate.now(); //年月日
LocalTime l1 = LocalTime.now(); //时分秒
LocalDateTime t1 = LocalDateTime.now(); //年月日时分秒纳秒
// 获取日期对象中的信息
int year = d1.getYear(); //年
int month = d1.getMonthValue(); //月(1-12)
int day = d1.getDayOfMonth(); //日
int dayOfYear = d1.getDayOfYear(); // 一年中的第几天
int day0fWeek = d1.getDay0fWeek().getValue(); // 星期几
// 2、 直接修改某个信息: witbYear、withMonth、withDayOfMonth、withDayofYear
LocalDate d2 = d1.witbYear(2024);
// 3、把某个信息加多少: plusYears、plusMonths、plusDays、plusWeeks
LocalDate d3 = d1.witbYear(1);
// 4.把某个信息减多少: minusYears、minusMonths、minusDays、minusWeeks
LocalDate d4 = d3.minusYears(1);
// 5、获取指定日期的LocalDate对象: public static LocalDate of(int yearint
//month,int dayOfMonth)
LocalDate d5 = LocalDate.of(2023,11,16)
LocalDate d6 = LocalDate.of(2023,12,16)
// 6、判断2个日期对象，是否相等，在前还是在后: equals isBefore isAfter
d1.equals(d4); // true
d5.isBefore(d6); // true
d5.isAfter(d6); // false
// 7、可以把LocdDateTime转换成LocaLDate和ocalTime
// public LocalDate toLocalate()
// public LocalTime tolocalTime()
// public static LocalDateTime of(LocaLDate date, LocalTime time)
LocalDate d7 = t1. toLocalDate();
LocaLDateTime t2 =ILocaLDateTime.of(d1， l1);
当要改变时间时原时间不会改变，会返回改变后的结果。
ZoneId、ZonedDateTime
Zoneld:代表时区Id，ZonedDateTime是带时区的时间
| 方法名 | 说明 |
| public static Set<String> getAvailableZonelds() | 获取Java中支持的所有时区 |
| public static Zoneld systemDefault() | 获取系统默认时区 |
| public static Zoneld of(String zoneld) | 获取一个指定时区 |
| 方法名 | 说明 |
| public static ZonedDateTime now() | 获取当前时区的ZonedDateTime对象 |
| public static ZonedDateTime now(Zoneld zone) | 获取指定时区的ZonedDateTime对象 |
| getYear、getMonthValue、 getDayOfMonth getDayOfYeargetDayOfWeek、getHour getMinute、 getSecond、 getNano | 获取年月日、时分秒、纳秒等 |
| public ZonedDateTime withXxx(时间) | 修改时间系列的方法 |
| public ZonedDateTime minusXxx(时间) | 减少时间系列的方法 |
| public ZonedDateTime plusxxx(时间) | 增加时间系列的方法 |
Instant
Instant是时间线上的某个时刻/时间戳。通过获取Instant的对象 可以拿到此刻的时间，该时间由两部分组成:从1970-01-01 00:00:00 开始走到此刻的总秒数+不够1秒的纳秒数（可以用来记录代码的执行时间，或用于记录用户操作某个事件的时间点。传统的Date类，只能精确到亳秒,并且是可变对象；新增的Instant类，可以精确到纳秒，并且是不可变对象,推荐用Instant代替Date。）
| 方法名 | 说明 |
| public static Instant now( ) | 获取当前时间的Instant对象(标准时间) |
| public 1ong getEpochSecond() | 获取从1970-01-01T00: 00: 00开始记录的秒数。 |
| public int getNano() | 从时间线开始，获取从第二个开始的纳秒数 |
| plusMillis plusSeconds plusNanos | 判断系列的方法 |
| minusMillis minusSeconds minusNanos | 减少时间系列的方法 |
| equals、isBefore、 isAfter | 增加时间系列的方法 |
DateTimeFormatter
格式化器，用于时间的格式化、解析
| 方法名 | 说明 |
| public static DateTimeFormatter ofPattern(时间格式) | 获取格式化器对象 |
| public String format( 时间对象) | 格式化时间 |
LocalDateTime提供的格式化、解析时间的方法
| 方法名 | 说明 |
| public String format(DateTimeFormatter formatter ) | 格式化时间 |
| public static LocalDateTime parse(CharSequence text, DateTimeFormatter formatter) | 解析时间 |
//格式化代码。
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日HH:mm:ss");
LocalDateTime now = LocaLDateTime.now();
//正向格式化。
String rs = formatter.format(now);
//正向格式化。
String rs2 = now.format(formatter);
//解析时间:解析时间一般使用LocaLDateTime提供的解析方法来解析。
String dateStr = "2029年12月12日 12:12:11";
LocalDateTime ldt = LocalDateTime.parse(dateStr,formatter);
System.out.printLn(ldt);
Period
●可以用于计算两个LocalDate对象相差的年数、月数、天数。
| 方法名 | 说明 |
| public static Period between(LocalDate start, LocalDate end) | 传入2个日期对象，得到Period对象 |
| public int getYears() | 计算隔几年，并返回 |
| public int getMonths() | 计算隔几个月，年返回 |
| public int getDays() | 计算隔多少天，并返回 |
LocalDate start = LocalDate.of(2029,8,10);
LocalDate end= LocaLDate.of(2029,8,15);
Period period = Period.between(start, end);
System.out.println(period.getYears());Duration
●可以用于计算两个时间对象相差的天数、小时数、分数、秒数、纳秒数;支持LocalTime、 LocalDateTime、Instant等时间。
| 方法名 | 说明 |
| public static Duration between( 开始时间对象1,截止时间对象2) | 传入2个时间对象，得到Duration对象 |
| public long toDays() | 计算隔多少天，并返回 |
| public long toHours() | 计算隔多少小时，并返回 |
| public long toMinutes() | 计算隔多少分，并返回 |
| public long toSeconds() | 计算隔多少秒，并返回 |
| public long toMillis() | 计算隔多少毫秒，并返回 |
| public long toNanos() | 计算隔多少纳秒，并返回 |
LocalDateTime start = LocalDateTime.of(2025,11,11,11,10,10);
LocalDateTime end = LocalDateTime.of(2025,11,11,11,11,11);
Duration duration = Duration.between(start,end);
System.out.printLn(duration.toMinutes()); //间隔多少分Arrays
概述
●用来操作数组的一个工具类。
常用方法
| 方法名 | 说明 |
| public static String toString(类型[ ] arr) | 返回数组的内容 |
| public static int[] copyOfRange(类型[ ] arr,起始索引,结束索引) | 拷贝数组（指定范围，包前不包后） |
| public static copyOf(类型[ ] arr, int newLength) | 拷贝数组 |
| public static setll(double[ ] array, IntToDoubleFunction generator) | 把数组中的原数据改为新数据 |
| public static void sort(类型[] arr) | 对数组进行排序(默认是升序排序) |
//public static setll(double[] array, IntToDoubleFunction generator)的用法示例
doubLe[] prices = {99.8, 128% 100};
Arrays.setAll(prices, new IntToDoubleFunction() {
@Override
public double applyAsDouble(int value) {
return prices[value] * 0.8;
}
})补充
如果数组中存储的是对像不能直接排序，可以自己制定一个排序规则后再排序
方式一：让该对象的类实现Comparable(比较规则)接口，然后重写compareTo方法，自己来制定比较规则。（在对象中重写）
public int compareTo(Student o) {
//约定1: 认为左边对象大于右边对象请您返回正整数
//约定2: 认为左边对象于右边对象请您返回负整数
//约定3: 认为左边对象等于右边对象请您一定返回0
//按照age升序排序。（比较的为整数）
if(this.age> o.age){
return 1;
}else if(this.age< o.age){
return -1;
}
return 0;
//上边比较的代码可用下列代码执行
return this.age- o.age;
}
方式二：使用下面这个sort方法，创建Comparator比较器接口的匿名内部类对象，然后自己制定比较规则
public static <T> void sort(TI] arr, Comparator<? superT> c)对数组进行排序(支持自定义排序规则)
Arrays.sort(students,new Comparator<Student> () {
@Override
public int compare(Student o1,Student o2) {
//约定1: 认为左边对象大于右边对象请您返回正整数
//约定2: 认为左边对象于右边对象请您返回负整数
//约定3: 认为左边对象等于右边对象请您一定返回0
//按照身高升序排序。（比较的为小数）
if(o1. getHeight() > o2. getHeight()){
return 1;
}else if(o1. getHeight() < o2. getHeight(){
return -1;
}
return 0;
}
//上边比较的代码可用下列代码执行
return DoubLe.compare(o1.getHeight(),o2.getHeight());
});JDK8新特性: Lambda表达式
概述
●Lambda表达式是JDK 8开始新增的一种语法形式；作用：用于简化匿名内部类的代码写法。Lambda表达式并不是说能简化全部匿名内部类的写法，只能简化函数式接口的匿名内部类。
函数式接口：有且仅有一个抽象方法的接口。
注意：将来我们见到的大部分函数式接口，上面都可能会有一个@FunctionalInterface的注解，有该注解的接口就必定是函数式接口。
格式
(被重写方法的形参列表) -> {
被重写方法的方法体代码。
}
示例
public class LambdaTest1 {
public static void main(String[] args) {
//简化前的写法
Swimming s = new Swimming(){
@Override
public void swim() {
System.out.println("学生快乐的游泳~~~");
}
};
s.swim();
//简化后的写法
Swimming s = () -> {
System.out.println("学生快乐的游泳~~~");
};
s.swim();
}
}
interface Swimming{
void swim();
}Lambda表达式的省略写法
进一步简化Lambda表达式的写法
●参数类型可以省略不写。
●如果只有一个参数，参数类型可以省略，同时()也可以省略。
●如果Lambda表达式中的方法体代码只有一行代码， 可以省略大括号不写，同时要省略分号！此时，如果这行代码是return语句，也必须去掉return不写。
Arrays.sort(students,(Student o1,Student o2) -> {
return DoubLe.compare(o1.getHeight(),o1.getHeight());
});
//上列代码可以简写成下列形式
Arrays.sort(students,(o1,o2) -> { DoubLe.compare(o1.getHeight(),o2.getHeight()));JDK8新特性:方法引用
概述
方法引用是用来进一步简化Lambda表达式的，方法引用的标志性符号 “::”
有四种常见的场景：静态方法的引用、实例方法的引用、特定类型方法的引用、构造器引用
静态方法的引用
格式
类名::静态方法
使用场景
●如果某个Lambda表达式里只是调用一个静态方法,并且前后参数的形式一致,就可以使用静态方法引用。
示例
//简化前
// Arrays.sort(students, (o1, o2) -> o1.getAge() - o2.getAge());
//简化后
Arrays.sort(students，CompareByData::compareByAge);
//简化后要有另一个class来装compareByAge的代码,如下
public class CompareByData {
public static int compareByAge (Student o1, Student o2){
return o1.getAge() - o2.getAge();
}
}实例方法的引用
格式
对象名::实例方法
使用场景
●如果某个Lambda表达式里只是调用一个实例方法,并且前后参数的形式一致, 就可以使用实例方法引用。
示例
//简化前
// Arrays.sort(students, (o1, o2) -> o1.getAge() - o2.getAge());
//简化后
CompareByData compare = new CompareByData();
Arrays.sort(students，compare::compareByAge);
//简化后要有另一个class来装compareByAge的代码,如下
public class CompareByData {
public int compareByAge (Student o1, Student o2){
return o1.getAge() - o2.getAge();
}
}特定类型方法的引用
格式
类型::方法
使用场景
●如果某个Lambda表达式里只是调用一个实例方法,并且前面参数列表中的第一个参数是作为方法的主调，后面的所有参数都是作为该实例方法的入参的，则此时就可以使用特定类型的方法引用。
示例
String[] names = {"boby", "angela", "Andy" , "dLei", "caocao", "Babo", "jack", "Cici"};
//简化前
Arrays.sort(names, ( o1，o2) -> o1.compareToIgnoreCase(o2) );
//简化后
Arrays.sort(names, String::compareToIgnoreCase);构造器引用
基本用不到
格式
类名::new
使用场景
●如果某个Lambda表达式里只是在创建对象，并且前后参数情况一致，就可以使用构造器引用。
2153
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
