01.JAVA8新特性

JAVA8新特性

1）接口中默认方法修饰为普通方法

2）lambda表达式（重点）

        ()参数列表

        ->分隔  

         {}方法体

3）函数式接口

4）方法与构造函数引用（重点）    

        静态方法引入：类名称::方法名称    

        对象方法引入：类名称::实例方法名称    

        实例方法引入：new对象 对象实例::方法引入    

        构造函数引入：类名::new

5）Stream接口（重点） 6）Optional

链接：https://pan.baidu.com/s/1s1207a7edyrTyjCUuLZ4yA 
提取码：aosh

1.接口中默认方法修饰为普通方法

/**
 * JDK8新特性--接口中默认方法修饰为普通方法
 */
public interface JDK8Interface {
    /**
     * 抽象方法 需要子类实现
     * 默认类型：public、abstract
     */
    void add();

    /**
     * default方法
     */
    default void defaultGet() {
        System.out.println("我是default方法");
    }

    /**
     * 静态方法
     */
    static void staticGet() {
        System.out.println("我是static方法");
    }
}

public class JDK8InterfaceImpl implements JDK8Interface {

    /**
     * 默认的情况下必须重写接口中抽象方法 默认和静态方法是不需要必须重写
     */
    @Override
    public void add() {
        System.out.println("add");
    }
}

public class Test01 {

    public static void main(String[] args) {
        JDK8InterfaceImpl jdk8Interface = new JDK8InterfaceImpl();
        jdk8Interface.add();
        JDK8Interface.staticGet();
        jdk8Interface.defaultGet();
    }
}

2.lambda表达式

1）使用lambda表达式调用无函数

@FunctionalInterface
public interface WuCanInterface {

    void get();
}

import com.demo.service.WuCanInterface;

/**
 * 使用lambda表达式调用无函数
 */
public class Test01 {

    public static void main(String[] args) {
        ((WuCanInterface)() -> System.out.println("使用lamdba表达式调用方法")).get();
    }
}

2）使用lambda表达式调用有参函数

@FunctionalInterface
public interface YouCanInterface {

    String get(int i, int j);
}

import com.demo.service.YouCanInterface;

/**
 * 使用lambda表达式调用有参函数
 */
public class Test02 {

    public static void main(String[] args) {
        String result = ((YouCanInterface)(i, j) -> i + "--" + j).get(1, 2);
        System.out.println(result);
    }
}

3）使用lambda表达式集合遍历

import java.util.ArrayList;

/**
 * 使用lambda表达式集合遍历
 */
public class Test03 {

    public static void main(String[] args) {
        ArrayList<String> strings = new ArrayList<>();
        strings.add("1");
        strings.add("2");
        strings.add("3");
        strings.forEach(s -> System.out.println(s));
    }
}

4）使用lambda表达式集合排序

import com.demo.entity.UserEntity;

import java.util.ArrayList;
import java.util.Comparator;

/**
 * 使用lambda表达式集合排序
 */
public class Test04 {

    public static void main(String[] args) {
        ArrayList<UserEntity> userLists = new ArrayList<>();
        userLists.add(new UserEntity("c", 12));
        userLists.add(new UserEntity("b", 6));
        userLists.add(new UserEntity("a", 23));

        //排序1
        userLists.sort((o1, o2) -> o1.getAge() - o2.getAge());
        userLists.forEach((t) -> System.out.println(t.toString()));

        //排序2
        userLists.sort(Comparator.comparing(UserEntity::getUserName));
        userLists.forEach((t) -> System.out.println(t.toString()));
    }
}

5）使用lambda表达式实现线程调用

/**
 * 使用lambda表达式实现线程调用
 */
public class Test05 {

    public static void main(String[] args) {
        new Thread(() -> System.out.println("我是子线程")).start();
        new Thread(() -> System.out.println("获取到线程名称:" + Thread.currentThread().getName() + "，子线程")).start();
    }
}

3.Stream接口

1）使用stream将list集合转换为set集合并去重

public class UserEntity {

    private String userName;

    private int age;

    public UserEntity() {

    }

    public UserEntity(String userName, int age) {
        this.userName = userName;
        this.age = age;
    }

    public String getUserName() {
        return userName;
    }

    public int getAge() {
        return age;
    }

    /**
     * 重写toString方法
     */
    @Override
    public String toString() {
        return "UserEntity{" + "userName='" + userName + '\'' + ", age=" + age + '}';
    }

    /**
     * 重写hashCode方法
     * 重写equals方法必须重写hashCode方法
     */
    public int hashCode() {
        return userName.hashCode();
    }

    /**
     * 重写equals方法
     */
    public boolean equals(Object obj) {
        if (obj instanceof UserEntity) {
            return userName.equals(((UserEntity)obj).userName) && age == (((UserEntity)obj).age);
        } else {
            return false;
        }
    }
}

import com.demo.entity.UserEntity;

import java.util.ArrayList;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * 使用stream将list集合转换为set集合并去重
 */
public class Test01 {

    /**
     * 获取串行流  .stream()
     * 获取并向流  .parallelStream()
     */
    public static void main(String[] args) {
        ArrayList<UserEntity> userEntities = new ArrayList<>();
        userEntities.add(new UserEntity("a", 20));
        userEntities.add(new UserEntity("b", 28));
        userEntities.add(new UserEntity("c", 35));

        //重写equals方法 比较值
        userEntities.add(new UserEntity("d", 16));
        userEntities.add(new UserEntity("d", 16));

        //获取stream流
        Stream<UserEntity> stream = userEntities.stream();
        //转换成set集合  set集合不允许有重复数据
        Set<UserEntity> setUserList = stream.collect(Collectors.toSet());
        //打印集合
        setUserList.forEach(userEntity -> System.out.println(userEntity.toString()));
    }
}

2）使用stream将list集合转换为map集合

import com.demo.entity.UserEntity;

import java.util.ArrayList;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * 使用stream将list集合转换为map集合
 */
public class Test02 {

    public static void main(String[] args) {
        ArrayList<UserEntity> userEntities = new ArrayList<>();
        userEntities.add(new UserEntity("a", 20));
        userEntities.add(new UserEntity("b", 28));
        userEntities.add(new UserEntity("c", 35));

        Stream<UserEntity> stream = userEntities.stream();
        Map<String, UserEntity> collect = stream.collect(Collectors.toMap(userEntity -> userEntity.getUserName(), userEntity -> userEntity));
        collect.forEach((o, o2) -> System.out.println(o + "," + o2));
    }
}

3）使用stream求和

import com.demo.entity.UserEntity;

import java.util.ArrayList;
import java.util.Optional;
import java.util.stream.Stream;

/**
 * 使用stream求和
 */
public class Test03 {

    public static void main(String[] args) {
        ArrayList<UserEntity> userEntities = new ArrayList<>();
        userEntities.add(new UserEntity("a", 1));
        userEntities.add(new UserEntity("b", 2));
        userEntities.add(new UserEntity("c", 3));
        userEntities.add(new UserEntity("d", 4));
        userEntities.add(new UserEntity("e", 5));
        userEntities.add(new UserEntity("f", 6));
        userEntities.add(new UserEntity("g", 7));
        Stream<UserEntity> stream = userEntities.stream();
        Optional<UserEntity> sum = stream.reduce((user1, user2) -> {
            UserEntity userEntity = new UserEntity("sum", user1.getAge() + user2.getAge());
            return userEntity;
        });
        System.out.println(sum.get().getAge());
    }
}

4）使用stream求最小值

import com.demo.entity.UserEntity;

import java.util.ArrayList;
import java.util.Optional;

/**
 * 使用stream求最小值
 */
public class Test04 {

    public static void main(String[] args) {
        ArrayList<UserEntity> userEntities = new ArrayList<>();
        userEntities.add(new UserEntity("a", 20));
        userEntities.add(new UserEntity("b", 28));
        userEntities.add(new UserEntity("c", 35));
        userEntities.add(new UserEntity("d", 21));
        userEntities.add(new UserEntity("e", 19));
        userEntities.add(new UserEntity("f", 1));
        userEntities.add(new UserEntity("g", 21));

        Optional<UserEntity> max = userEntities.stream().min((o1, o2) -> o1.getAge() - o2.getAge());
        System.out.println(max.get());
    }
}

5）使用stream查询是否有匹配数据

import com.demo.entity.UserEntity;

import java.util.ArrayList;

/**
 * 使用stream查询是否有匹配数据
 */
public class Test05 {

    public static void main(String[] args) {
        ArrayList<UserEntity> userEntities = new ArrayList<>();
        userEntities.add(new UserEntity("a", 20));
        userEntities.add(new UserEntity("b", 28));
        userEntities.add(new UserEntity("c", 35));
        userEntities.add(new UserEntity("d", 21));
        userEntities.add(new UserEntity("e", 19));
        userEntities.add(new UserEntity("f", 19));
        userEntities.add(new UserEntity("g", 21));
        boolean b = userEntities.stream().anyMatch(userEntity -> "a".equals(userEntity.getUserName()));
        System.out.println(b);
    }
}

6）使用stream filter过滤

import com.demo.entity.UserEntity;

import java.util.ArrayList;

/**
 * 使用stream filter过滤
 */
public class Test06 {

    public static void main(String[] args) {
        ArrayList<UserEntity> userEntities = new ArrayList<>();
        userEntities.add(new UserEntity("a", 20));
        userEntities.add(new UserEntity("b", 28));
        userEntities.add(new UserEntity("c", 35));
        userEntities.add(new UserEntity("d", 21));
        userEntities.add(new UserEntity("e", 19));
        userEntities.add(new UserEntity("f", 19));
        userEntities.add(new UserEntity("g", 21));
        userEntities.add(new UserEntity("h", 12));

        userEntities.stream().filter(userEntity -> "a".equals(userEntity.getUserName()) && userEntity.getAge() > 18)
            .forEach((userEntity -> System.out.println(userEntity)));
    }
}

7）使用stream limit分页

import com.demo.entity.UserEntity;

import java.util.ArrayList;

/**
 * 使用stream limit分页
 */
public class Test07 {

    public static void main(String[] args) {
        ArrayList<UserEntity> userEntities = new ArrayList<>();
        userEntities.add(new UserEntity("a", 20));
        userEntities.add(new UserEntity("b", 28));
        userEntities.add(new UserEntity("c", 35));
        userEntities.add(new UserEntity("d", 21));
        userEntities.add(new UserEntity("e", 19));
        userEntities.add(new UserEntity("f", 19));
        userEntities.add(new UserEntity("g", 21));

        // 从第2+1个开始 取3个
        userEntities.stream().skip(2).limit(3).forEach((userEntity -> System.out.println(userEntity)));
    }
}

8）使用stream sorted排序

import com.demo.entity.UserEntity;

import java.util.ArrayList;

/**
 * 使用stream sorted排序
 */
public class Test08 {

    public static void main(String[] args) {
        ArrayList<UserEntity> userEntities = new ArrayList<>();
        userEntities.add(new UserEntity("a", 20));
        userEntities.add(new UserEntity("b", 28));
        userEntities.add(new UserEntity("c", 35));
        userEntities.add(new UserEntity("d", 21));
        userEntities.add(new UserEntity("e", 19));
        userEntities.stream().sorted((o1, o2) -> o2.getAge() - o1.getAge()).forEach((userEntity -> System.out.println(userEntity.toString())));
    }
}

4.方法与构造函数引用

1）静态方法引入

@FunctionalInterface
public interface MessageInterface {

    void get(Integer a,Integer b);
}

import com.demo.service.MessageInterface;

/**
 * 静态方法引入：类名称::方法名称
 * 强制：引入方法的参数和返回类型 要和 函数接口的参数和返回类型 保持一致
 */
public class Test01 {

    public static void main(String[] args) {
        MessageInterface messageInterface3 = Test01::staticGet;
        messageInterface3.get(10, 20);
    }

    public static void staticGet(Integer a, Integer b) {
        System.out.println("staticGet,a:" + a + ",b:" + b);
    }
}

2）实例方法引入

@FunctionalInterface
public interface MessageInterface2 {

    String getMessage();
}

import com.demo.service.MessageInterface2;

/**
 * 实例方法引入：new对象 对象实例::方法引入
 */
public class Test02 {

    public static void main(String[] args) {
        MessageInterface2 messageInterface = new Test02()::objGet;
        System.out.println(messageInterface.getMessage());
    }

    public String objGet() {
        return "test";
    }
}

3）构造函数引入

public class MessageEntity {

    private String messageId;
    private String messageName;

    public MessageEntity() {

    }

    @Override
    public String toString() {
        return "MessageEntity{" + "messageId='" + messageId + '\'' + ", messageName='" + messageName + '\'' + '}';
    }
}

import com.demo.entity.MessageEntity;

@FunctionalInterface
public interface MessageInterface3 {

    MessageEntity getMessage();
}

import com.demo.entity.MessageEntity;
import com.demo.service.MessageInterface3;

/**
 * 构造函数引入：类名::new
 */
public class Test03 {

    public static void main(String[] args) {
        MessageInterface3 messageInterface3 = MessageEntity::new;
        System.out.println(messageInterface3.getMessage());
    }
}

4）对象方法引入

import com.demo.method.Test04;

public interface MkService {

    String get(Test04 Test04);
}

import com.demo.service.MkService;

/**
 * 对象方法引入：类名称::实例方法名称
 */
public class Test04 {

    public static void main(String[] args) {
        MkService mkService = Test04::get;
        System.out.println(mkService.get(new Test04()));
    }

    public String get() {
        return "TEST";
    }

}

5）方法引入：获取字符串长度

import java.util.function.Function;

/**
 * 方法引入：获取字符串长度
 */
public class Test05 {

    public static void main(String[] args) {
        Function<String, Integer> function = String::length;
        System.out.println(function.apply("test"));
    }
}

5.Optional方法

1）Optional方法 判断对象是否为空

import java.util.Optional;

/**
 * Optional方法 判断对象是否为空
 */
public class Test01 {

    /**
     * Optional.ofNullable 可以允许传递一个空值对象
     * Optional.of 不允许传递一个空值对象
     */
    public static void main(String[] args) {
        String userName = null;

        //1.ofNullable 可以允许传递一个空值对象
        Optional<String> optional = Optional.ofNullable(userName);
        //不为空返回true，为空返回false
        System.out.println(optional.isPresent());
        //获取值
        System.out.println(optional.get());

        //2.of 不允许传递一个空值对象
        Optional<String> optional1 = Optional.of(userName);

        //3.orElse 如果为空设置默认值
        String uName = Optional.ofNullable(userName).orElse("aa");
        System.out.println(uName);
    }
}

2）Optional方法 过滤空值

import java.util.Optional;

/**
 * Optional方法 过滤空值
 */
public class Test02 {

    public static void main(String[] args) {
        String userName = "11";
        Optional<String> optional = Optional.ofNullable(userName);
        optional.ifPresent(System.out::println);
    }
}

3）Optional方法 案例1

public class OrderEntity {

    private String orderId;
    private String orderName;
    private String orderDes;

    public OrderEntity(String orderId, String orderName) {
        this.orderId = orderId;
        this.orderName = orderName;
    }

    public String getOrderId() {
        return orderId;
    }

    public String getOrderName() {
        return orderName;
    }

    public String getOrderDes() {
        return orderDes;
    }
}

import com.demo.entity.OrderEntity;

import java.util.Optional;

/**
 * Optional方法 案例1
 * orElseGet()---写函数的接口的形式 赋默认值
 * orElse()----直接传递默认值
 */
public class Test03 {

    private static OrderEntity orderEntity;

    public static void main(String[] args) {
        System.out.println(Test03.getOrder());
        System.out.println(Test03.getOrder());
    }

    public static OrderEntity getOrder() {
        return Optional.ofNullable(orderEntity).orElseGet(Test03::orElseGet);
    }

    private static OrderEntity createOrder() {
        return new OrderEntity("123456", "aa");
    }

    public static OrderEntity orElseGet() {
        orderEntity = createOrder();
        return orderEntity;
    }
}

4）Optional方法 案例2：将字符串全部转换为小写

import com.demo.entity.OrderEntity;

import java.util.Optional;

/**
 * Optional方法 案例2：将字符串全部转换为小写
 */
public class Test04 {

    public static void main(String[] args) {
        String orderName = Test04.getOrderName();
        System.out.println(orderName);
    }

    public static String getOrderName() {
        OrderEntity order = new OrderEntity("123456", "XiangQian");
        return Optional.ofNullable(order).map(orderEntity -> orderEntity.getOrderName())
            .map(orderName -> orderName.toLowerCase()).orElse(null);
    }
}