jdk8新特性 – 源码巴士

jdk8

1，lambda表达式

lambda表达式一般是和函数式接口一起使用的，函数式接口就是只有一个抽象方法的接口，这里需要注意的是object中的方法是可以在函数式接口中重写的。

如果不使用lambda表达式的话，我们可以这样写：

public interface AcanthopanaxInterface {

    /**
     * 测试
     */
    void get();
}

public class Test1 {
    public static void main(String[] args) {
        new AcanthopanaxInterface(){
            @Override
            public void get() {
                System.out.println("aaa");
            }
        }.get();
    }
}
使用匿名内部类的方式：创建这个接口，然后实现抽象方法，最后调用即可

①无参方法

这里这样写是因为没有返回值类型，如果有返回值的话，那么就需要一个变量来进行接收。

如果方法体中只有一行代码的话，那么{}就可以省略不写了

接口名 方法参数 方法体
((AcanthopanaxInterface) () -> System.out.println("aaa")).get();

②有参有返回值的方法

这个和无参的时候是一样的，只不过需要有一个返回值，并且如果方法体中只有一行返回值的代码的时候，return也是可以省略的

public interface YouShenInterface {

    String get(int i, int j);
}

public class Test2 {
    public static void main(String[] args) {

        System.out.println(((YouShenInterface) (i, j) -> i + "-" + j).get(1, 1));
    }
}

③lambda来遍历集合

public class Test3 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("123");
        list.add("456");
        list.add("789");
        list.forEach((s) -> System.out.println(s));
    }
}

或者有一种更简单的方法：
public class Test3 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("123");
        list.add("456");
        list.add("789");
        list.forEach(System.out::println);
    }
}

④lambda集合排序

public class UserEntity {
    private String name;
    private Integer age;

    public UserEntity(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public Integer getAge() {
        return age;
    }

    @Override
    public String toString() {
        return "UserEntity{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}


public class Test4 {
    public static void main(String[] args) {
        ArrayList<UserEntity> userlists = new ArrayList<>();
        userlists.add(new UserEntity("mayikt", 22));
        userlists.add(new UserEntity("xiaomin", 18));
        userlists.add(new UserEntity("xiaoha", 36));

        userlists.sort((o1, o2) ->
                o1.getAge() - o2.getAge()
        );
        userlists.forEach((Consumer) o -> System.out.println("o:" + o.toString()));

    }
}

⑤线程调用

public class Test5 {
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("我是子线程1");
            }
        }).start();
        new Thread(()-> System.out.println("我是子线程2")).start();
    }
}

2，stream流

Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。Stream API可以极大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。

这种风格将要处理的元素集合看作一种流，流在管道中传输，并且可以在管道的节点上进行处理，比如筛选，排序，聚合等。

元素流在管道中经过中间操作（intermediate operation）的处理，最后由最终操作(terminal operation)得到前面处理的结果。

Stream ：非常方便精简的形式遍历集合实现过滤、排序等。

Stream创建方式：

parallelStream为并行流采用多线程执行
Stream采用单线程执行

parallelStream效率比Stream要高。

①Stream将list转换为Set

public class Test01 {
    public static void main(String[] args) {
        ArrayList<UserEntity> userEntities = new ArrayList<>();
        userEntities.add(new UserEntity("mayikt", 20));
        userEntities.add(new UserEntity("meite", 28));
        userEntities.add(new UserEntity("zhangsan", 35));
        userEntities.add(new UserEntity("xiaowei", 16));
        userEntities.add(new UserEntity("xiaowei", 16));
        userEntities.forEach((t) -> {
            System.out.println(t.toString());
        });
        System.out.println("取出重复...");

        Stream<UserEntity> stream = userEntities.stream();
        // 转换成set集合
        Set<UserEntity> setUserList = stream.collect(Collectors.toSet());
        setUserList.forEach(userEntity -> System.out.println(userEntity.toString()));
    }
}

②Stream将list转换为Map

public static void main(String[] args) {
        ArrayList<UserEntity> userEntities = new ArrayList<UserEntity>();
        userEntities.add(new UserEntity("mayikt", 20));
        userEntities.add(new UserEntity("meite", 28));
        userEntities.add(new UserEntity("zhangsan", 35));
        userEntities.add(new UserEntity("xiaowei", 16));
        Stream<UserEntity> stream = userEntities.stream();
        // key 为string类型 value UserEntity  集合中的数据：UserEntity , string类型
        Map<String, UserEntity> collect = stream.collect(Collectors.toMap(new Function<UserEntity, String>() {
            @Override
            public String apply(UserEntity userEntity) {
                return userEntity.getUserName();
            }
        }, new Function<UserEntity, UserEntity>() {
            @Override
            public UserEntity apply(UserEntity userEntity) {
                return userEntity;
            }
        }));
        collect.forEach(new BiConsumer<String, UserEntity>() {
            @Override
            public void accept(String s, UserEntity userEntity) {
                System.out.println(s + "\t:\t" + userEntity.toString());
            }
        });
    }

③Stream将Reduce 求和

public static void main(String[] args) {
    Stream<Integer> integerStream = Stream.of(10, 30, 80, 60, 10, 70);
    Optional<Integer> reduce = integerStream.reduce((a1, a2) -> a1 + a2);
    System.out.println(reduce.get());
}

④StreamMax和Min

注意：stream流只能被消费一次，如果还需要使用的话，那么就需要重新创建了。

public static void main(String[] args) {
    ArrayList<UserEntity> userEntities = new ArrayList<UserEntity>();
    userEntities.add(new UserEntity("mayikt", 20));
    userEntities.add(new UserEntity("meite", 28));
    userEntities.add(new UserEntity("zhangsan", 35));
    userEntities.add(new UserEntity("xiaowei", 16));
    Stream<UserEntity> stream1 = userEntities.stream();
    Optional<UserEntity> max = stream1.max(new Comparator<UserEntity>() {
        @Override
        public int compare(UserEntity o1, UserEntity o2) {
            return o1.getAge() - o2.getAge();
        }
    });
    System.out.println(max.get());
    Stream<UserEntity> stream2 = userEntities.stream();
        Optional<UserEntity> min = stream2.min(((o1, o2) -> o1.getAge() - o2.getAge()));
    System.out.println(min.get());
}

⑤StreamMatch 匹配

anyMatch表示，判断的条件里，任意一个元素成功，返回true

allMatch表示，判断条件里的元素，所有的都是，返回true

noneMatch跟allMatch相反，判断条件里的元素，所有的都不是，返回true

public static void main(String[] args) {
    ArrayList<UserEntity> userEntities = new ArrayList<UserEntity>();
    userEntities.add(new UserEntity("mayikt", 20));
    userEntities.add(new UserEntity("meite", 28));
    userEntities.add(new UserEntity("zhangsan", 35));
    userEntities.add(new UserEntity("xiaowei", 16));
    Stream<UserEntity> stream = userEntities.stream();
    boolean result = stream.noneMatch(new Predicate<UserEntity>() {
        @Override
        public boolean test(UserEntity userEntity) {
            return userEntity.getAge() > 35;
        }
    });
    System.out.println(result);
    Stream<UserEntity> stream2 = userEntities.stream();
    boolean result2 = stream2.noneMatch((user) -> user.getAge() > 35);
    System.out.println(result2);
}

⑥StreamFor循环

public static void main(String[] args) {
    ArrayList<UserEntity> userEntities = new ArrayList<UserEntity>();
    userEntities.add(new UserEntity("mayikt", 20));
    userEntities.add(new UserEntity("meite", 28));
    userEntities.add(new UserEntity("zhangsan", 35));
    userEntities.add(new UserEntity("xiaowei", 16));
    Stream<UserEntity> stream = userEntities.stream();
    stream.forEach(new Consumer<UserEntity>() {
        @Override
        public void accept(UserEntity userEntity) {
            System.out.println(userEntity.toString());
        }
    });
    Stream<UserEntity> stream2 = userEntities.stream();
    stream2.forEach(userEntity -> System.out.println(userEntity.toString()));
}

⑦Stream过滤器

public static void main(String[] args) {
    ArrayList<UserEntity> userEntities = new ArrayList<UserEntity>();
    userEntities.add(new UserEntity("mayikt", 20));
    userEntities.add(new UserEntity("meite", 28));
    userEntities.add(new UserEntity("zhangsan", 35));
    userEntities.add(new UserEntity("xiaowei", 16));
    Stream<UserEntity> stream = userEntities.stream();
    stream.filter(new Predicate<UserEntity>() {
        @Override
        public boolean test(UserEntity userEntity) {
            return userEntity.getAge() >= 35;
        }
    }).filter(new Predicate<UserEntity>() {
        @Override
        public boolean test(UserEntity userEntity) {
            return userEntity.getUserName().equals("zhangsan");
        }
    }).forEach(new Consumer<UserEntity>() {
        @Override
        public void accept(UserEntity userEntity) {
            System.out.println(userEntity.toString());
        }
    });

    Stream<UserEntity> stream2 = userEntities.stream();
    stream2.filter((userEntity -> userEntity.getAge() >= 35)).filter(userEntity -> userEntity.equals("zhangsan"))
            .forEach((userEntity -> System.out.println(userEntity)));
}

⑧Stream排序 sorted

public static void main(String[] args) {
    ArrayList<UserEntity> userEntities = new ArrayList<UserEntity>();
    userEntities.add(new UserEntity("mayikt", 20));
    userEntities.add(new UserEntity("meite", 28));
    userEntities.add(new UserEntity("zhangsan", 35));
    userEntities.add(new UserEntity("xiaowei", 16));
    Stream<UserEntity> stream = userEntities.stream();
    stream.sorted(new Comparator<UserEntity>() {
        @Override
        public int compare(UserEntity o1, UserEntity o2) {
            return o1.getAge() - o2.getAge();
        }
    }).forEach(new Consumer<UserEntity>() {
        @Override
        public void accept(UserEntity userEntity) {
            System.out.println(userEntity.toString());
        }
    });
    Stream<UserEntity> stream2 = userEntities.stream();
    stream2.sorted(((o1, o2) -> o1.getAge() - o2.getAge())).forEach(userEntity -> System.out.println(userEntity.toString()));
}

⑨Stream limit和skip

Limit 从头开始获取

Skip 就是跳过

public static void main(String[] args) {
    ArrayList<UserEntity> userEntities = new ArrayList<UserEntity>();
    userEntities.add(new UserEntity("mayikt", 20));
    userEntities.add(new UserEntity("meite", 28));
    userEntities.add(new UserEntity("zhangsan", 35));
    userEntities.add(new UserEntity("xiaowei", 16));
    Stream<UserEntity> stream = userEntities.stream();
    stream.skip(2).limit(1).forEach(userEntity -> System.out.println(userEntity));
}

⑩Stream 综合案例

要求：对数据流的数据实现降序排列、且名称包含mayikt 获取前两位

public static void main(String[] args) {
    ArrayList<UserEntity> userEntities = new ArrayList<>();
    userEntities.add(new UserEntity("mayikt", 20));
    userEntities.add(new UserEntity("meite", 28));
    userEntities.add(new UserEntity("zhangsan", 35));
    userEntities.add(new UserEntity("xiaowei", 16));
    userEntities.add(new UserEntity("mayikt_list", 109));
    userEntities.add(new UserEntity("mayikt_zhangsan", 110));
    userEntities.add(new UserEntity("lisi", 109));
    //要求：对数据流的数据实现降序排列、且名称包含mayikt 获取前两位
    userEntities.stream().filter(userEntity -> userEntity.getUserName().contains("mayikt_")).limit(2)
            .sorted((o1, o2) -> o1.getAge() - o2.getAge())
            .forEach(userEntity -> System.out.println(userEntity.toString()));

}

原文链接：https://blog.csdn.net/weixin_51604685/article/details/126218417