JAVA8 函数式编程

一、Lambda表达式

1.Lambda 表达式的由来

为了编写这类处理批量数据的并行类库，需要在语言层面上修改现有的 Java：增加 Lambda 表达式。

2.什么是函数式编程

在思考问题时，使用不可变值和函数，函数对一个值进行处理，映射成另一个值。

3.Lambda 表达式的不同形式

#无参无返回的lambda表达式
Runnable noArguments = () -> System.out.println("Hello World"); 

#有参无返回的lambda表达式
ActionListener oneArgument = event -> System.out.println("button clicked"); 

#将行为写在大括号里的lambda表达式
Runnable multiStatement = () -> {
System.out.print("Hello");
System.out.println(" World");
};

#有参又返回省略参数类型的lambda表达式
BinaryOperator<Long> add = (x, y) -> x + y; 

#有参又返回的lambda表达式
BinaryOperator<Long> addExplicit = (Long x, Long y) -> x + y;

4.自定一个Lambda表达式及简单使用

1.定义一个函数接口

public interface Operate {
   boolean getResult(int t);
}

2.lambda表达式的使用（传入行为）

Operate operate = (c) -> c > 5;

3.lambda表达式的调用（实现）

boolean b=operate.getResult(3);

这里的operate 就是一个行为，在使用lambda表达式的时候我们可以通过传入不同的行为如( c ) -> c <5,那么我们就会得到我们想要的另一种结果，这就是函数式编程。

5.java为我们提供的函数接口

接口	参数	返回类型	示例
Predicate	T	boolean	这张唱片已经发行了吗
Consumer	T	void	输出一个值
Function<T,R>	T	R	获得 Artist 对象的名字
Supplier	None	T	工厂方法
UnaryOperator	T	T	逻辑非（!）
BinaryOperator	(T, T)	T 求两个数的乘积（*）

二、流式编程

java.util.Stream 表示能应用在一组元素上一次执行的操作序列。Stream 操作分为中间操作或者最终操作两种，最终操作返回一特定类型的计算结果，而中间操作返回Stream本身，这样你就可以将多个操作依次串起来。当最终操作发生时则次操作序列结束。Stream 的创建需要指定一个数据源，比如 java.util.Collection的子类，List或者Set。Stream的操作可以串行执行或者并行执行。

下面我们直接上代码展示Stream的用法

1.准备工作给定一个实体类StreamUseEntity

import lombok.Data;
import java.util.List;


public class StreamUseEntity {

    @Data
    public class Test{
        private String s;
    }

    @Data
    public static class Artist {
        private String name;
        private List<String> members;
        private String origin;
    }

    @Data
    public static class Track {
        private String name;
    }

    @Data
    public static class Album {
        private String name;
        private List<Track> tracks;
        private List<Artist> artists;
    }
}

2.Stream测试类

import org.junit.Before;
import org.junit.Test;
import java.util.*;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import static com.zzx.insert.lambda.StreamUseEntity.*;


public class SimpleLambda {
    private List<Album> albums;
    private List<Artist> artists;
    private List<Track> tracks;


    @Before
    public void before() {
        Track track = new Track();
        track.setName("hello lambda");
        Track track1 = new Track();
        track1.setName("It's my life");
        tracks = Arrays.asList(track, track1);

        Artist artist = new Artist();
        artist.setName("theband");
        artist.setMembers(Arrays.asList("zhangsan", "lisi"));
        artist.setOrigin("china");

        Artist artist1 = new Artist();
        artist1.setName("theband2");
        artist1.setMembers(Arrays.asList("holi", "mota"));
        artist1.setOrigin("america");

        Artist artist2 = new Artist();
        artist2.setName("person");
        artist2.setMembers(Arrays.asList("zhangsan", "lisi", "wang"));
        artist2.setOrigin("china");
        artists = Arrays.asList(artist, artist1, artist2);

        Album album = new Album();
        album.setArtists(artists);
        album.setTracks(tracks);
        album.setName("album");

        Track trackx = new Track();
        trackx.setName("hello lambda 2");
        Track trackx1 = new Track();
        trackx1.setName("It's my life 2");
        List<Track> tracksx = Arrays.asList(trackx, trackx1);

        Artist artistx = new Artist();
        artistx.setName("theband 2");
        artistx.setMembers(Arrays.asList("zhangsan 2", "lisi 2"));
        artistx.setOrigin("china");

        Artist artistx1 = new Artist();
        artistx1.setName("theband2 2");
        artistx1.setMembers(Arrays.asList("holi 2", "mota 2"));
        artistx1.setOrigin("america");

        Artist artistx2 = new Artist();
        artistx2.setName("person 2");
        artistx2.setMembers(Arrays.asList("zhangsan 2", "lisi 2"));
        artistx2.setOrigin("china");
        List<Artist> artistsx = Arrays.asList(artistx, artistx1, artistx2);
        Album album1 = new Album();
        album1.setArtists(artistsx);
        album1.setTracks(tracksx);
        album1.setName("album1");
        albums = Arrays.asList(album, album1);
    }


    public void test(BinaryOperator<Integer> plus, int a, int b) {
        plus.apply(a, b);
    }

    public interface MyFunction<R, T> {
        R apply(T t);
    }


    public void streamTest() {
        List<String> collected = Stream.of("a", "b", "c")
                .collect(Collectors.toList());
        System.out.println(collected.get(0));
    }


    public void listStream() {
        List<Integer> integerList = Arrays.asList(1, 2, 3);
        Set<String> stringList = integerList.stream().map(String::valueOf).collect(Collectors.toCollection(HashSet::new));
    }


    /**
     * 收集器
     */
    @Test
    public void biggestGroup() {
        Function<Artist, Integer> getCount = artist -> artist.getMembers().size();

        Optional result = artists.stream().collect(Collectors.maxBy(Comparator.comparing(getCount)));
        result.ifPresent(count -> System.out.println(count));
    }


    /**
     * 收集器，求平均
     */
    @Test
    public void avrageMusicNum() {
        double result = albums.stream().collect(Collectors.averagingDouble(target -> target.getTracks().size()));
        System.out.println(result);
    }


    /**
     * 收集器，布尔分组
     */
    @Test
    public void partitionTest() {
        Map<Boolean, List<Artist>> result = albums.stream()
                .flatMap(art -> art.getArtists().stream())
                .collect(Collectors.partitioningBy(arts -> arts.getName().startsWith("the")));
        System.out.println(result);
    }

    /**
     * 收集器，分组
     */
    @Test
    public void groupingByTest() {
        Map<String, List<Artist>> result = albums.stream()
                .flatMap(art -> art.getArtists().stream())
                .collect(Collectors.groupingBy(Artist::getName));
        System.out.println(result);
    }

    /**
     * 收集器，字符串处理
     */
    @Test
    public void toStringTest() {
        String result = albums.stream()
                .flatMap(art -> art.getArtists().stream())
                .map(Artist::getName)
                .collect(Collectors.joining(",", "[", "]"));
        System.out.println(result);
    }

    /**
     * 收集器，分组，并且分组后计数
     */
    @Test
    public void groupingCountTest() {
        Map<String, Long> result = albums.stream()
                .flatMap(art -> art.getArtists().stream())
                .collect(Collectors.groupingBy(Artist::getName, Collectors.counting()));
        System.out.println(result);
    }

    /**
     * 收集器嵌套，分组，并且分组后把一种结果转换成另一种结果
     */

    @Test
    public void groupingCountTest2() {
        Map<String, List<Character>> result = albums.stream()
                .flatMap(art -> art.getArtists().stream())
                .collect(Collectors.groupingBy(Artist::getName, Collectors.mapping(Artist::getName, Collectors.mapping(str -> str.charAt(0), Collectors.toList()))));
        System.out.println(result);
    }

    @Test
    public void diyCollector() {
    }

    /**
     * 练习
     */
    @Test
    public void practice(){
        Map<String, Long> result = Stream.of("sadf", "sdf", "sdf").collect(Collectors.groupingBy(a-> a, Collectors.counting()));
        System.out.println(result);
    }
}

三、推荐资源

《JAVA8 函数式编程》

大家要想了解得更深入推荐大家看看《JAVA8 函数式编程》这本书。