Java8-lambda表达式

匿名接口方法

package lambda;


public class Lambda1 {
    public static void main(String[] args) {
        LambdaNoneReturnNoneParameter lambda1 = () ->
                System.out.println("LambdaNoneReturnNoneParameter");
        lambda1.test();

        LambdaNoneReturnSingleParameter lambda2 = a ->
                System.out.println("LambdaNoneReturnSingleParameter: " + a);
        lambda2.test(10);

        LambdaNoneReturnMultiParameter lambda3 = (a, b) ->
                System.out.println("LambdaNoneReturnMultiParameter: " + a + ", " + b);
        lambda3.test(5, 10);

        LambdaHasReturnNoneParameter lambda4 = () -> 10;
        System.out.println("LambdaHasReturnNoneParameter: "+ lambda4.test());

        LambdaHasReturnSingleParameter lambda5 = a -> a;
        System.out.println("LambdaHasReturnSingleParameter: "+ lambda5.test(10));

        LambdaHasReturnMultiParameter lambda6 = (a, b) -> a * b;
        System.out.println("LambdaHasReturnSingleParameter: "+ lambda6.test(10, 5));
    }
}

@FunctionalInterface
interface LambdaNoneReturnNoneParameter {
    void test();
}

@FunctionalInterface
interface LambdaNoneReturnSingleParameter {
    void test(int a);
}

@FunctionalInterface
interface LambdaNoneReturnMultiParameter {
    void test(int a, int b);
}

@FunctionalInterface
interface LambdaHasReturnNoneParameter {
    int test();
}

@FunctionalInterface
interface LambdaHasReturnSingleParameter {
    int test(int a);
}

@FunctionalInterface
interface LambdaHasReturnMultiParameter {
    int test(int a, int b);
}

方法引用

package lambda;

public class Lambda2 {
    public static void main(String[] args) {
        LambdaHasReturnSingleParameter lambda1 = a -> change(a);
        System.out.println("a -> change(a): " + lambda1.test(10));

        LambdaHasReturnSingleParameter lambda2 = Lambda2::change;
        System.out.println("Lambda2::change: " + lambda2.test(10));

        PersonCreator creator = () -> new Person();

        PersonCreator creator1 = Person::new;
        System.out.println(creator1.getPerson());

        PersonCreator2 creator2 = Person::new;
        System.out.println(creator2.getPerson("CT", 25));
    }

    public static int change(int a) {
        return a * 10;
    }
}

@FunctionalInterface
interface LambdaHasReturnSingleParameter {
    int test(int a);
}

@FunctionalInterface
interface PersonCreator{
    Person getPerson();
}

@FunctionalInterface
interface PersonCreator2{
    Person getPerson(String name, int age);
}

class Person{
    private String name;
    private int age;

    public Person() {
        System.out.println("Person无参构造方法执行");
    }

    public Person(String name, int age) {
        System.out.println("Person全参构造方法执行");
        this.name = name;
        this.age = age;
    }

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

集合排序与遍历

package lambda;

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

public class Lambda3 {
    public static void main(String[] args) {
        ArrayList<Person> list = new ArrayList<Person>(){{
            add(new Person("tom", 10));
            add(new Person("john", 17));
            add(new Person("tony", 13));
            add(new Person("marry", 15));
            add(new Person("jack", 12));
        }};
        list.sort((o1, o2) -> o1.getAge() - o2.getAge());
        list.forEach(System.out::println);

        list.sort(Comparator.comparingInt(Person::getAge).reversed());
        list.forEach(System.out::println);

        Collections.sort(list, Comparator.comparingInt(Person::getAge));
        list.forEach(System.out::println);
    }
}

class Person{
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public int getAge() {
        return age;
    }

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

匿名排序比较

package lambda;

import java.util.Comparator;
import java.util.TreeSet;

public class Lambda4 {
    public static void main(String[] args) {
        TreeSet<Person> set = new TreeSet<Person>(
                Comparator.comparingInt(Person::getAge)){{
            add(new Person("tom", 10));
            add(new Person("john", 17));
            add(new Person("tony", 13));
            add(new Person("mark", 13));
            add(new Person("marry", 15));
            add(new Person("jack", 12));
        }};

        set.forEach(System.out::println);

        TreeSet<Person> set1 = new TreeSet<Person>(
                (o1, o2) -> o1.getAge() <= o2.getAge() ? -1 : 1){{
            add(new Person("tom", 10));
            add(new Person("tony", 13));
            add(new Person("john", 17));
            add(new Person("mark", 13));
            add(new Person("marry", 15));
            add(new Person("jack", 12));
        }};
        set1.forEach(System.out::println);

        set1.removeIf(ele -> ele.getAge() > 12);
        System.out.println(set1);
    }
}

class Person{
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public int getAge() {
        return age;
    }

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

系统内置的一些函数式接口

package lambda;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.*;

public class FunctionalInterface {
    public static void main(String[] args) {
        // 系统内置的一些函数式接口

//        Predicate<T>        :   参数T     返回值boolean
//        Consumer<T>         :   参数T     返回值void
//        Function<T, R>      :   参数T     返回值R
//        Supplier<T>         :   参数无     返回值T
//        UnaryOperator<T>    :   参数T     返回值T
//        BinaryOperator<T>   :   参数T, T  返回值T
//        BiFunction<T, U, R> :   参数T, U  返回值R
//        BiPredicate<T, U>   :   参数T, U  返回值boolean
//        BiConsumer<T, U>    :   参数T, U  返回值void

        System.out.println(filterNum(Arrays.asList(3, 5, 6, 7, 2, 1), e -> e > 3));

        cost(100, m -> System.out.println("cost:" + m));

        System.out.println(strHandler("\t\t\tHello World", e -> e.trim()));

        System.out.println(createRandom(5, () -> (int) (Math.random() * 100)));

    }

    public static List<Integer> filterNum(List<Integer> list, Predicate<Integer> predicate) {
        List<Integer> newList = new ArrayList<>();
        for (Integer integer : list) {
            if (predicate.test(integer)) {
                newList.add(integer);
            }
        }
        return newList;
    }

    public static void cost(int money, Consumer<Integer> consumer) {
        consumer.accept(money);
    }

    public static String strHandler(String str, Function<String, String> func) {
        return func.apply(str);
    }

    public static List<Integer> createRandom(int length, Supplier<Integer> supplier) {
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < length; i++) {
            list.add(supplier.get());
        }
        return list;
    }
}

闭包中使用的变量变final修饰的常量

Stream-创建stream

package lambda;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

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

        // 1.Collection.stream() or Collection.parallelStream()
        List<String> list = new ArrayList<>();
        Stream<String> stream = list.stream();
        Stream<String> stream1 = list.parallelStream();

        // 2.Arrays.stream()
        Person[] persons = new Person[5];
        Stream<Person> stream2 = Arrays.stream(persons);

        // 3.Stream.of()
        Stream<Integer> stream3 = Stream.of(1, 2, 3);

        // 4.创建无限流
        // 迭代
        Stream<Integer> stream4 = Stream.iterate(0, x -> x + 1);
        stream4.limit(10).forEach(System.out::println);

        // 生成
        Stream<Integer> stream5 = Stream.generate(() -> (int) (Math.random() * 100));
        stream5.limit(5).limit(10).forEach(System.out::println);
    }
}

Stream-筛选与切片

package lambda;

import java.util.ArrayList;
import java.util.List;

public class Data {

    public static List<Employee> eList = null;

    public static List<Employee> getEList(){
        if(eList == null)
            eList =  new ArrayList<Employee>(){{
                add(new Employee("tom", 10, 12000.00));
                add(new Employee("john", 17, 12500.00));
                add(new Employee("tony", 13, 17000.00));
                add(new Employee("mary", 15, 15000.00));
                add(new Employee("mary", 15, 15000.00));
                add(new Employee("jack", 12, 13000.00));
            }};
        return eList;
    }

    public static List<Employee> getESList(){
        if(eList == null)
            eList =  new ArrayList<Employee>(){{
                add(new Employee("tom", 10, 12000.00, Status.BUSY));
                add(new Employee("john", 17, 12500.00, Status.FREE));
                add(new Employee("tony", 13, 17000.00, Status.VOCATION));
                add(new Employee("mary", 15, 15000.00, Status.BUSY));
                add(new Employee("mary", 15, 15000.00, Status.FREE));
                add(new Employee("jeff", 15, 15000.00, Status.FREE));
                add(new Employee("jack", 12, 13000.00, Status.VOCATION));
            }};
        return eList;
    }
}

package lambda;

import java.util.List;

public class LambdaStream2 {
    public static void main(String[] args) {
        List<Employee> list = Data.getEList();
        list.stream().filter(e -> e.getAge() > 12).forEach(System.out::println);
        System.out.println("--------------");

        list.stream()
                .filter(e -> e.getSalary() >= 12000)
                .limit(3)
                .forEach(System.out::println);
        System.out.println("--------------");

        list.stream()
                .filter(e -> e.getSalary() >= 12000)
                .skip(3)
                .distinct()
                .forEach(System.out::println);
    }
}

Stream-映射

package lambda;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

public class LambdaStream3 {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("aaa", "bbb", "ccc", "ddd");
        list.stream().map(e -> e.toUpperCase()).forEach(System.out::println);
        System.out.println("-----------------");

        List<Employee> eList = Data.getEList();
        eList.stream().map(e -> e.getName().toUpperCase()).forEach(System.out::println);
        System.out.println("-----------------");

        list.stream().flatMap(LambdaStream3::filterCharacter).forEach(System.out::println);
    }

    public static Stream<Character> filterCharacter(String str){
        List<Character> list = new ArrayList<>();
        for (char c : str.toCharArray()) {
            list.add(c);
        }
        return list.stream();
    }
}

Stream-排序

package lambda;

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

public class LambdaStream4 {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("aaa", "bbb", "ccc", "ddd");
        list.stream()
                .sorted(Comparator.reverseOrder())
                .forEach(System.out::println);

        List<Employee> employees = Data.getEList();
        employees.stream()
                .sorted((o1, o2) -> o1.getAge().equals(o2.getAge()) ?
                        o1.getName().compareTo(o2.getName()) :
                        o1.getAge().compareTo(o2.getAge()))
                .forEach(System.out::println);
    }
}

Stream-查找匹配

package lambda;

import java.util.Comparator;
import java.util.List;
import java.util.Optional;

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

        List<Employee> employees = Data.getESList();

        System.out.println(employees.stream().allMatch(e -> e.getStatus().equals(Status.BUSY)));

        System.out.println(employees.stream().anyMatch(e -> e.getStatus().equals(Status.BUSY)));

        System.out.println(employees.stream().noneMatch(e -> e.getStatus().equals(Status.BUSY)));

        System.out.println(employees.stream()
                .sorted(Comparator.comparingDouble(Employee::getSalary).reversed())
                .findFirst().get());

        System.out.println(employees.stream()
                .filter(e -> e.getStatus().equals(Status.FREE))
                .findAny().get());

        System.out.println(employees.stream().count());

        System.out.println(employees.stream()
                .max(Comparator.comparingDouble(Employee::getSalary)).get());

        System.out.println(employees.stream()
                .map(Employee::getSalary).min(Double::compareTo).get());
    }
}

Stream-规约

package lambda;

import java.util.*;
import java.util.stream.Collectors;

public class LambdaStream6 {
    public static void main(String[] args) {
        List<Employee> employees = Data.getESList();
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
        System.out.println(list.stream().reduce(0, (x, y) -> x + y));

        System.out.println(employees.stream().map(Employee::getSalary).reduce(Double::sum).get());

        employees.stream().map(Employee::getName)
                .collect(Collectors.toList()).forEach(System.out::println);
        System.out.println("---------------------");

        employees.stream().map(Employee::getName)
                .collect(Collectors.toSet()).forEach(System.out::println);
        System.out.println("---------------------");

        employees.stream().map(Employee::getName)
                .collect(Collectors.toCollection(TreeSet::new)).forEach(System.out::println);

        System.out.println(employees.stream().collect(Collectors.counting()));

        System.out.println(employees.stream().collect(
                Collectors.averagingDouble(Employee::getSalary)));

        System.out.println(employees.stream().collect(
                Collectors.summingDouble(Employee::getSalary)));

        System.out.println(employees.stream().collect(
                Collectors.maxBy(Comparator.comparingDouble(Employee::getSalary))).get());

        System.out.println(employees.stream()
                .map(Employee::getSalary).collect(Collectors.minBy(Double::compareTo)).get());

        System.out.println(employees.stream().collect(Collectors.groupingBy(Employee::getStatus)));

        System.out.println(employees.stream().collect(
                Collectors.groupingBy(Employee::getStatus, Collectors.groupingBy(e -> {
                    if (e.getAge() <= 35) {
                        return "青年";
                    } else if (e.getAge() <= 50) {
                        return "中年";
                    } else {
                        return "老年";
                    }
                }))));

        System.out.println(employees.stream().collect(Collectors.partitioningBy(e -> e.getSalary() >= 12500)));

        DoubleSummaryStatistics dss = employees.stream()
                .collect(Collectors.summarizingDouble(Employee::getSalary));
        System.out.println(dss.getSum());
        System.out.println(dss.getAverage());
        System.out.println(dss.getMax());

        System.out.println(employees.stream()
                .map(Employee::getName).collect(Collectors.joining(",")));
    }
}

集合中的lambda操作

public class lambdaMain {

    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        for (int i = 30; i > 0; i--) {
            list.add(i % 9);
        }
        list.removeIf(integer -> integer < 3);
        list.sort(Comparator.comparingInt(Integer::intValue));
        System.out.println(list);

        List<Integer> list1 = null;
        System.out.println(Optional.ofNullable(list1)
                .orElse(new ArrayList<>(Arrays.asList(1 ,2, 3)))
                .stream().anyMatch(e -> e > 1));

        Map<Integer, Integer> map = new HashMap<>();
        list.forEach(e -> map.merge(e, 2, (oldValue, newValue) -> oldValue * newValue));
        System.out.println(map);

        Map<Integer, Integer> map1 = new HashMap<>();
        list.forEach(e -> map1.compute(e, (k, v) -> v == null ? 1 : ++v));
        System.out.println(map1);

        map1.computeIfPresent(3, (k, v) -> 0);
        System.out.println(map1);

        map1.computeIfPresent(3, (k, v) -> null);
        System.out.println(map1);

        map1.computeIfAbsent(3, k -> 1000);
//        等价于
//        map1.putIfAbsent(3, 1000);
        System.out.println(map1);
    }

}