Java 函数式接口和Stream流

---

函数式接口

函数式接口在JDK java.util.function包中

四种常用接口：

代码演示：

消费型接口：

public class ConsumerDemo {
    public static void main(String[] args) {
        //消费型接口
        //匿名内部类的写法
        Consumer<String> consumer = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        consumer.accept("asdf");

        //jdk8的写法
        Consumer<String> consumer1 = s -> {
            System.out.println(s);
        };
        consumer1.accept("123456");
    }
}

运行结果：

asdf
123456

函数型接口：

public class FunctionDemo {
    public static void main(String[] args) {
        // 函数型接口，一个参数，一个返回值
        //匿名内部类的写法
        Function<String, Integer> function = new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                return s.length();
            }
        };
        System.out.println(function.apply("asdf"));

        //jdk8的写法
        Function<String, Integer> function1 = (s -> {return s.length();});
        System.out.println(function1.apply("123456"));
    }
}

运行结果：

4
6

判定型接口：

public class PredicateDemo {
    public static void main(String[] args) {
        //判定型接口
        //匿名内部类的写法
        Predicate<String> predicate = new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.length()>3;
            }
        };
        System.out.println(predicate.test("asdf"));

        //jdk8的写法
        Predicate<String> predicate1 = (s) -> {
            return s.length()>10;
        };
        System.out.println(predicate1.test("asdf"));
    }
}

运行结果：

true
false

供应型接口：

public class SupplierDemo {
    public static void main(String[] args) {
        //供应型接口
        //匿名内部类的写法
        Supplier<Integer> supplier = new Supplier<Integer>() {
            @Override
            public Integer get() {
                return 1024;
            }
        };
        System.out.println(supplier.get());

        //jdk8的写法
        Supplier<Integer> supplier1 = () -> {
            return 996;
        };
        System.out.println(supplier1.get());
    }
}

运行结果：

1024
996

---

Stream流

Stream流是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。

“集合讲的是数据，流讲的是计算！”

Stream流相当于是SQL，SQL对数据库进行操作，Stream流对集合中的元素进行操作。

Stream流的特点：

1. Stream自己不会存储元素。

2. Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。

3. Stream操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。

Stream流的使用：

1. 创建—个Stream：一个数据源（数组、集合)。
2. 中间操作:一个中间操作，处理数据源数据。
3. 终止操作:一个终止操作，执行中间操作链，产生结果。

题目：
  请按照给出数据，找出同时满足偶数ID且年龄大于24且用户名转为大写且用户名字母倒排序；最后只输出一个用户名字

代码演示：

package test2;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

class User
{
    private Integer id;
    private String  userName;
    private int     age;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public User(Integer id, String userName, int age) {
        this.id = id;
        this.userName = userName;
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", userName='" + userName + '\'' +
                ", age=" + age +
                '}';
    }
}

/**
 * @create 2019-02-26 22:24
 *
 * 题目：请按照给出数据，找出同时满足
 *      偶数ID且年龄大于24且用户名转为大写且用户名字母倒排序
 *      最后只输出一个用户名字
 */
public class StreamDemo
{
    public static void main(String[] args)
    {
        User u1 = new User(11,"a",23);
        User u2 = new User(12,"b",24);
        User u3 = new User(13,"c",22);
        User u4 = new User(14,"d",28);
        User u5 = new User(16,"e",26);

        List<User> list = Arrays.asList(u1,u2,u3,u4,u5);

        //使用filter()过滤出ID是偶数且年龄大于24的用户 filter()需要传一个判断型函数
        //collect()可以将Stream流转换为集合
        List<User> list1 = list.stream().filter(user -> {
            return user.getId() % 2 == 0 && user.getAge() > 24;
        }).collect(Collectors.toList());
        list1.forEach(System.out::println);

        System.out.println("----------------");

        //使用map()将用户名转换为大写，返回值会将传进去的参数替换掉，如果返回的是字符串，就会得到一个装着字符串的集合
        List<User> list2 = list1.stream().map(user -> {
            user.setUserName(user.getUserName().toUpperCase());
            return user;
        }).collect(Collectors.toList());
        list2.forEach(System.out::println);

        System.out.println("----------------");

        //将用户的名字进行到排序
        List<User> list3 = list2.stream().sorted(((o1, o2) -> {
            return o2.getUserName().compareTo(o1.getUserName());
        })).collect(Collectors.toList());
        list3.forEach(System.out::println);

        System.out.println("----------------");

        //使用map()提取出名字，并将第一个结果进行输出  得到最终答案
        List<String> list4 = list3.stream().map(user -> {
            return user.getUserName();
        }).limit(1).collect(Collectors.toList());
        list4.forEach(System.out::println);
    }
}

运行结果：

User{id=14, userName='d', age=28}
User{id=16, userName='e', age=26}
----------------
User{id=14, userName='D', age=28}
User{id=16, userName='E', age=26}
----------------
User{id=16, userName='E', age=26}
User{id=14, userName='D', age=28}
----------------
E

Process finished with exit code 0

使用链式编码，可以简化为如下代码

        List<String> list5 = list.stream().filter(p -> {
            return p.getId() % 2 == 0;
        }).filter(p -> {
            return p.getAge() > 24;
        }).map(f -> {
            return f.getUserName().toUpperCase();
        }).sorted((o1, o2) -> {
            return o2.compareTo(o1);
        }).limit(1).collect(Collectors.toList());
        list5.forEach(System.out::println);

运行结果：

E