【Java基础】JDK8新特性最佳实践_jdk8实战

JDK安装

• win64位-JDK1.8下载||https://pan.baidu.com/s/1fMNaZ0JgySo2MzBT90T5Tw ||jjw3
• Linux64位-JDK1.8||https://pan.baidu.com/s/1CDpW-UNYyje-p0BxaNtncQ ||nwyd
• Mac-JDK1.8下载||https://pan.baidu.com/s/1liT9kSLicpXEAd7AdA0nOg ||5bpk

1.接口默认方法实现

• 在jdk1.8以前接⼝⾥⾯是只能有抽象⽅法，不能有任何⽅法的实现的
• jdk1.8⾥⾯打破了这个规定，引⼊了新的关键字default，使⽤default修饰⽅法，可以在接⼝⾥⾯定义具体的⽅法实现
• 默认⽅法： 接⼝⾥⾯定义⼀个默认⽅法，这个接⼝的实现类实现了这个接⼝之后，不⽤管这个default修饰的⽅法就可以直接调⽤，即接⼝⽅法的默认实现

（1）编写接口

public interface Animal {
   

    void run();

    void eat();

    /**
     * 接口的默认方法
     */
    default void sleep(){
   
        System.out.println("睡觉");
    }

    /**
     * 静态方法
     */
    static void st(){
   
        System.out.println("静态方法");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

（2）编写实现类

public class Dog implements Animal{
   
    @Override
    public void run() {
   
        System.out.println("小狗跑");
    }

    @Override
    public void eat() {
   
        System.out.println("小狗吃");
    }

    public static void main(String[] args) {
   
        Dog dog = new Dog();
        dog.run();
        dog.eat();
        //直接能掉接口的默认实现
        dog.sleep();
        //直接调用静态方法
        Animal.st();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

（3）运行结果

2.新增Base64加解密API

2.1.Base64编码简介

Base64是网络上常见的用于传输8Bit字节码的编码方式之一，Base64就是一种基于64个可打印字符来表示二进制数据的方法，基于64个字符A-Z、0-9、a-z、+、/的编码方式，是一种能将任意二级制数据用64种字节组合成字符串的方法，而这个二进制数据和字符串资料之间是可以相互转换的，实际应用上，Base64不但可以将二进制数据可视化，还可以用于数据传输的加密
1

2.2.JDK1.8之前Base64的API

• 早期使用JDK里sun.misc套件下的BASE64Encoder和BASE64Decoder这两个类

（1）编码实战

    public static void main(String[] args) {
   
        
        //目标字符串
        String str = "lixiang";
        
        //加密
        BASE64Encoder encoder = new BASE64Encoder();
        String strEncode = encoder.encode(str.getBytes("UTF-8"));
        System.out.print("加密后："+strEncode);
        
        //解密
        BASE64Decoder decoder = new BASE64Decoder();
        String strDecode = new String(decoder.decodeBuffer(strEncode),"UTF-8");
        System.out.print("解密后："+strDecode);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

（2）运行结果

• 缺点：编码和解码的效率比较差，公开信息说以后要取消这个方法
• Apache Commons Codec有提供Base64的编码与解码，但是需要引第三方依赖

2.3.JDK1.8之后Base64的API

• JDK1.8之后java.util中提供了Base64的类

（1）编码实战

    public static void main(String[] args) {
   
        
        //目标字符串
        String str = "lixiang";
        
        //加密
        Base64.Encoder encoder = Base64.getEncoder();
        String strEncode = encoder.encodeToString(str);
        System.out.print("加密后："+strEncode);
        //解密
        Base64.Decoder decoder = Base64.getDecoder();
        String strDecoder = new String(decoder.decode(strEncode),"UTF-8");
        System.out.print("解密后："+strDecoder); 
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

（2）运行结果

• 优点：不需要引包，效率远大于un.misc 和 Apache Commons Codec

3.时间日期处理类

• 时间处理JDK1.8之前用的是SimpleDateFormat，Calendar等类，缺点是java.util.Date是线程不安全的，而且日期/时间对象比较，加减麻烦
• JDK1.8新发布Date-Time API进行加强对日期时间的处理
• 包所在位置：java.time
• 核心类

LocalDate:不包含具体时间的日期
LocalTime:不包含日期的时间
LocalDateTime:包含了日期及时间
1
2
3

3.1.LocalDate常用的API

LocalDate today = LocalDate.now();

获取当前日期的年份：today.getYear()

获取当前日期的月份：today.getMonth()

获取当前日期的月份（数字）：today.getMonthValue()

获取当前日期是当月的多少号：today.getDayOfMonth()

获取当前日期是这一周的周几：today.getDayOfWeek();

获取当前日期+1年,必须返回新的对象才会+1：today.plusYears(1)

获取当前日期+1月,必须返回新的对象才会+1：today.plusMonths(1)

获取当前日期+1周,必须返回新的对象才会+1：today.plusWeeks(1)

获取当前日期+1天,必须返回新的对象才会+1：today.plusDays(1)

获取当前日期-1天,必须返回新的对象才会-1：today.minusDays(1)

获取当前日期-1周,必须返回新的对象才会-1：today.minusWeeks(1)

获取当前日期-1年,必须返回新的对象才会-1：today.minusYears(1)

获取当前日期-1月,必须返回新的对象才会-1：today.minusMonths(1)

日期比较，当前日期与目标日期之后：date.isAfter(today)

日期比较，当前日期与目标日期之前：date.isBefore(today)

修改当前日期的年份：today.withYear(1999)

修改当前日期的月份：today.withMonth(3)

修改当前对象在当月的日期：today.withDayOfMonth(5)

比较两个日期是否相等：date.isEqual(today)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

3.2.日期格式化

• JDK1.8之前：SimpleDateFormat来进行格式化，但SimpleDateFormat并不是线程安全的
• JDK1.8之后：引入线程安全的日期与时间DateTimeFormatter

//获取当前时间
LocalDateTime today = LocalDateTime.now();
System.out.println("today:"+today);

//日期格式化
LocalDateTime today = LocalDateTime.now();
DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String date = dtf.format(today);
1
2
3
4
5
6
7
8

//定制日期对象,参数分别对应，年、月、日、时、分、秒
LocalDateTime localDateTime = LocalDateTime.of(2021,11,12,8,10,2);
1
2

3.3.日期的比较

LocalDateTime date1 = LocalDateTime.of(2021,11,12,8,10,2);
LocalDateTime date2 = LocalDateTime.of(2020,11,12,8,10,2);

Duration duration = Duration.between(date1,date2);
//两个时间差的天数
System.out.println(duration.toDays());
//两个时间的小时差
System.out.println(duration.toHours());
//两个时间的分钟差
System.out.println(duration.toMinutes());
//两个时间的毫秒差
System.out.println(duration.toMillis());
//两个时间的纳秒差
System.out.println(duration.toNanos());
1
2
3
4
5
6
7
8
9
10
11
12
13
14

4.空指针处理Optional类

（1）Optional类的用处

主要解决的问题是空指针异常（NullPointerException）

（2）创建Optional类

• of
  • null值作为参数传进去会报异常
  • Optional optional = Optional.of(空对象);

• ofNullable
  • null值作为参数传进去不会报异常
  • Optional optional = Optional.ofNullable(空对象);

（3）访问Optional对象的值

• get
  • 获取Optional对象中的值
  • optional.get()
• isPresent
  • 判断optional是否存在，如果不存在返回false，一般在获取Optional对象中的值之前调用判断
  • optional.isPresent()

Student student = null;

//Optional<Student> optional = Optional.of(student);

Optional<Student> optional = Optional.ofNullable(student);

//拿值之前先判断optional是否为空
if(optional.isPresent()){
   
     Student student1 = optional.get();
}else{
   
     System.out.println("optional中值为空");
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

（4）兜底orElse方法

• orElse()如果有只就返回该值，否则就传送一个默认值

Student student1 = null;
Student student2 = new Student("李祥",20);

//当student1为空时，就返回student2对象，不为空就返回student1对象
Student orElse = Optional.ofNullable(student1).orElse(student2);

System.out.println(orElse);
1
2
3
4
5
6
7

//判断对象年龄如果为空值就传送一个默认7
Optional.ofNullable(student1).map(obj->obj.getAge()).orElse(7);
System.out.println("age:"+integer);
1
2
3

5.Lambda表达式

（1）什么是Lambda表达式

• 在JDK8之前，java是不支持函数式编程的，所谓函数编程，可以理解成将一个函数（行为动作）作为一个方法的参数传递过去执行，面向对象编程是对数据的抽象，而函数式编程是对行为的抽象

（2）JDk8之前创建线程的方式与Lambda创建线程的方式

• JDK8之前创建线程

public static void main(String[] args) {
   

    new Thread(new Runable(){
   
        @Override
        public void run(){
   
            System.out.print("测试");
        }
    }).start();

}
1
2
3
4
5
6
7
8
9
10
11
12
13

• Lambda表达式创建线程

public static void main(String[] args) {
   
	
    //new Thread(()->{System.out.print("测试");}).start();
    new Thread(()->System.out.print("测试")).start();
}
1
2
3
4
5
6

（3）集合容器元素排序

• JDK8之前集合排序

public static void main(String[] args) {
   
	Arrays.asList("aaa","bbb","ccc","fff","ddd");
    Collections.sort(list,new Comparator<String>(){
   
        @Override
        public int compare(String a,String b){
   
            return a.compareTo(b);
        }
    });
}
1
2
3
4
5
6
7
8
9
10
11
12

• Lambda表达式方式排序

public static void main(String[] args) {
   
	Arrays.asList("aaa"
1
2