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

public interface Animal {
    void run();
    void eat();
    /**
     * 接口的默认方法
     */
    default void sleep(){
        System.out.println("睡觉");
    }
    /**
     * 静态方法
     */
    static void st(){
        System.out.println("静态方法");
    }
}

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();
    }
}

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

    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);
    }

    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); 
    }

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

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)

//获取当前时间
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);

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

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());

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中值为空");
}

Student student1 = null;
Student student2 = new Student("李祥",20);
//当student1为空时，就返回student2对象，不为空就返回student1对象
Student orElse = Optional.ofNullable(student1).orElse(student2);
System.out.println(orElse);

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

public static void main(String[] args) {
    new Thread(new Runable(){
        @Override
        public void run(){
            System.out.print("测试");
        }
    }).start();
}

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

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);
        }
    });
}

public static void main(String[] args) {
  Arrays.asList("aaa","bbb","ccc","fff","ddd");
    Collections.sort(list,(x,y) -> x.comparaTo(y));
}

一个接口中只包含一个需要实现的方法，可以使用Lambda表达式，这样的接口称为函数式接口，语法：(params) -> expression
(x,y) -> {System.out.print(x+y);}
(x,y):这一部分为参数，当只有一个参数时可以省略括号，x->,当没有参数时，直接写括号()
->:表示指向执行的方法体
{System.out.print(x+y);}:表示执行的方法体，可以是表法式，也可以是代码块，当是表达式的时候可以省略{}，没有{}时;不要写，代码块时要加上{}，就和平常的语句逻辑一样。
好处：Lambda表达式的实现方式时在本质以匿名内部类的方式进行实现，减少代码冗余，提高开发效率。

@FunctionInterface
public interface OperFunction<R,T>{
    R operator(T t1,T t2);
}

public static Integer operator(Integer x,Integer y,OperFunction<Integer,Integer> of){
    return of.operator(x,y);
}

public static void main(String[] args) {
    System.out.print(operator(x,y,(x,y)->x+y));
    System.out.print(operator(x,y,(x,y)->x-y));
    System.out.print(operator(x,y,(x,y)->x*y));
    System.out.print(operator(x,y,(x,y)->x/y));
}