Java 8函数式编程实战（一）Lambda表达式

背景介绍

开篇之前，按照惯例，先介绍一下为什么要编写这个系列的博文。因为最近想系统的学习下java8的一些新特性，即使在日常工作中经常使用，但有些使用的姿势跟背后的思想还是没有领悟到精髓，特此买了本《Java 8函数式编程实战》来学习一下，本系列的博文主要也是沿用该书脉络，使用每个章节中提出的一些练习，重点会突出实践，理论的东西点到为止，如果想深入了解请阅读该书，特别不错噢~
特别说明：本系列的分享重点突出实践，通过分析一些实战练习，从中去提炼一些理论要点

Lambda表达式

代码示例

特别说明，本系列博客中的示例一部分来源于《Java 8函数式编程实战》，这部分示例围绕这“音乐”这个领域，下面的代码包含：Artist 类（创作音乐的个人或团队）、Track类（专辑中的一支曲目）、Album（专辑，由若干曲目组成）、SampleData类（初始化样例数据构建的类）。为了后续不在重复以上公共基础类，特此摘要如下：

• Artist 类（创作音乐的个人或团队）

public final class Artist {
    
   /**
     * 艺术家的名字（例如：“甲壳虫乐队”）
     */
    private String name;
    /**
     * 乐队成员（例如“约翰·列侬”），该字段可为空
     */
    private List<Artist> members;
    /**
     * 乐队来自哪里（例如“利物浦”）
     */
    private String nationality;
    
    public Artist(String name, String nationality) {
        this(name, Collections.emptyList(), nationality);
    }

    public Artist(String name, List<Artist> members, String nationality) {
        Objects.requireNonNull(name);
        Objects.requireNonNull(members);
        Objects.requireNonNull(nationality);
        this.name = name;
        this.members = new ArrayList<>(members);
        this.nationality = nationality;
    }

    /**
     * @return the name
     */
    public String getName() {
        return name;
    }

    /**
     * @return the members
     */
    public Stream<Artist> getMembers() {
        return members.stream();
    }

    /**
     * @return the nationality
     */
    public String getNationality() {
        return nationality;
    }

    public boolean isSolo() {
        return members.isEmpty();
    }

    public boolean isFrom(String nationality) {
        return this.nationality.equals(nationality);
    }

    @Override
    public String toString() {
        return getName();
    }

    public Artist copy() {
        List<Artist> members = getMembers().map(Artist::copy).collect(toList());
        return new Artist(name, members, nationality);
    }

}

• Track类（专辑中的一支曲目）

public final class Track {
    
    /**
     * 曲目名称（例如《黄色潜水艇》）
     */
    private final String name;
    /**
     * 曲目时常（单位毫秒）
     */
    private final int length;

    public Track(String name, int length) {
        this.name = name;
        this.length = length;
    }

    /**
     * @return the name
     */
    public String getName() {
        return name;
    }

    /**
     * @return the length of the track in milliseconds.
     */
    public int getLength() {
        return length;
    }

    public Track copy() {
        return new Track(name, length);
    }

}

• Album（专辑，由若干曲目组成）

public final class Album implements Performance {
    
   /**
     * 专辑名（例如《左轮手枪》）
     */
    private String name;
    /**
     * 专辑上所有曲目的列表
     */
    private List<Track> tracks;
    /**
     * 参与创作本专辑的艺术家列表
     */
    private List<Artist> musicians;

    public Album(String name, List<Track> tracks, List<Artist> musicians) {
        Objects.requireNonNull(name);
        Objects.requireNonNull(tracks);
        Objects.requireNonNull(musicians);

        this.name = name;
        this.tracks = new ArrayList<>(tracks);
        this.musicians = new ArrayList<>(musicians);
    }

    /**
     * @return the name
     */
    public String getName() {
        return name;
    }

    /**
     * @return the tracks
     */
    public Stream<Track> getTracks() {
        return tracks.stream();
    }

    /**
     * Used in imperative code examples that need to iterate over a list
     */
    public List<Track> getTrackList() {
        return unmodifiableList(tracks);
    }

    /**
     * @return the musicians
     */
    public Stream<Artist> getMusicians() {
        return musicians.stream();
    }

    /**
     * Used in imperative code examples that need to iterate over a list
     */
    public List<Artist> getMusicianList() {
        return unmodifiableList(musicians);
    }

    public Artist getMainMusician() {
        return musicians.get(0);
    }

    public Album copy() {
        List<Track> tracks = getTracks().map(Track::copy).collect(toList());
        List<Artist> musicians = getMusicians().map(Artist::copy).collect(toList());
        return new Album(name, tracks, musicians);
    }

}

• SampleData类（初始化样例数据构建的类）

public class SampleData {

    public static final Artist johnColtrane = new Artist("John Coltrane", "US");
    public static final Artist johnLennon = new Artist("John Lennon", "UK");
    public static final Artist paulMcCartney = new Artist("Paul McCartney", "UK");
    public static final Artist georgeHarrison = new Artist("George Harrison", "UK");
    public static final Artist ringoStarr = new Artist("Ringo Starr", "UK");

    public static final List<Artist> membersOfTheBeatles = Arrays.asList(johnLennon, paulMcCartney, georgeHarrison, ringoStarr);

    public static final Artist theBeatles = new Artist("The Beatles", membersOfTheBeatles, "UK");

    public static final Album aLoveSupreme = new Album("A Love Supreme", asList(new Track("Acknowledgement", 467), new Track("Resolution", 442)), asList(johnColtrane));

    public static final Album sampleShortAlbum = new Album("sample Short Album", asList(new Track("short track", 30)), asList(johnColtrane));

    public static final Album manyTrackAlbum = new Album("sample Short Album", asList(new Track("short track", 30), new Track("short track 2", 30), new Track("short track 3", 30), new Track("short track 4", 30), new Track("short track 5", 30)), asList(johnColtrane));

    public static Stream<Album> albums = Stream.of(aLoveSupreme);

    public static Stream<Artist> threeArtists() {
        return Stream.of(johnColtrane, johnLennon, theBeatles);
    }

    public static List<Artist> getThreeArtists() {
        return Arrays.asList(johnColtrane, johnLennon, theBeatles);
    }

}

特别说明

java8的最大变化是引入了lambda表达式——一种紧凑的、传递行为的方式。它也是本系列后续所述内容的基础，所以本博文《Java 8函数式编程实战（一）Lambda表达式》内容将会持续的更新，lambda表达式也会渗透到后续所述的章节中，敬请期待，也欢迎大家一起交流学习~