拥抱新年代的Java

Java作为面向目标编程的主力言语,曾经风行一时,在Web范畴是绝对的老迈。随着时间的推移,一些新的编程范式不断的呈现,如函数式编程,呼应式编程,以及对函数的全力支撑(Lambda函数)变成了我们常常谈论的论题。移动互联网的呈现,以及前端的流行,让新一代的编程言语如Scala,Groovy,Swift以及Kotlin都大受欢迎。以函数式编程为中心的新一代编程范式慢慢变成了干流。曾经的王者Java,一度被人垢病,由于对函数支撑不友好,(其实最首要的原因是怎么坚持好向后兼容),但也与时俱进,总算在Java 8版别迈出了重大的一步,彻底支撑了函数式编程。本篇将要点评论Java 8的新特性,以及怎么用Java 8来实践函数式编程。

拥抱新时代的Java

Lambda表达式

也即匿名函数,称之为lambda。具体数学上的界说比较杂乱就不多说了。为了便于了解,我们先从匿名内部类说起。

拥抱新时代的Java

Java早就支撑匿名内部类,这是在当年相比较C++一个重要大的提升,它在一些需求提供行为完成的当地仍是十分便利的,典型的比如便是UI中的点击事件的处理:

button.addActionListener(new ActionListener() {
    @Override
    void actionPerformed(ActionEvent e) {
        System.out.println("Button is clicked: " + e);
    }
});

这儿的要点便是我们向button传递的是一个行为,也便是说按扭点击了时,要执行什么样的行为。比照其他现代言语,这仍是显得有些粗笨,没有简略明了的说明意图。用Java 8,这就好办多了,能够这样写:

button.addActionListener(e -> System.out.println("Button is clicked: " + e);

括号里边这一坨便是一个Lambda表达式,它是一个行为(严厉来说是一个函数),用以直接向目标目标传递一个行为,比照前面的比如,能够发现,这种场景下运用Lambda愈加的简洁高效。

Lambda表达式的语法

它的通用语法是:

(p1, p2....) -> {
    statements;
}

括号里边是参数列表,当只要一个参数时,括号可省掉,但当参数多于1个时,或许显现声明了参数类型时,括号不能省掉,如:

names.sort((a, b) -> b.compareTo(a));
button.addActionListener((ActionEvent e) -> System.out.println("Button is clicked: " + e));

花括号中便是语句块了,这跟惯例语句块(如if, while等)是相同的,假设有回来值就return,把它了解为惯例办法的实体就能够了,像写惯例函数完成那样去写就好了。假设只要一个语句,或许一条表达式,能够省掉花括号。

类型揣度

Lambda表达是匿名函数,首要用以向目标目标传递行为,既然匿名,当然是图简洁和明晰,因而就不要弄的太杂乱。所以,参数的类型,以及表达式的回来值(如有)的类型,都是编译器经过上下文来揣度出来的,因而,不用给参数写类型,假设由于完成的接口不明确,编译器看不懂的话,会有编译报错的。

关于类型揣度能够看《Java 8函数式编程》的第2章第5节有具体的评论。

闭包

也便是closure,严厉的数学界说就不说了,有点杂乱和难于了解,简略来说便是Lambda表达中运用了一个其界说域外的变量的值(称作捕获外部变量),lambda即变成了一个闭包。仍是有点绕,这个其实并不生疏,曾经的匿名内部便是能够运用外部变量的,只不过编译器要强加final润饰,如:

final int numberOfStudents = countStudents();
button.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
        System.out.println("Number of students is " + numberOfStudents);
    }
}

这儿其实便是一个闭包了,匿名内部类中捕获了外部的变量numberOfStudents,只不过要强加final润饰,这是由于这儿要传值。

Java 8里边呢,外部变量不用用final润饰了,可是,它也有必要实际上是final的:

int numberOfStudents = countStudents();
button.addActionListener(e -> System.out.println("Number of students is " + numberOfStudents));

由于,之前啊,假设捕获了一个外部变量,不是final的,会有编译错误,但假设你用IDE的建议时,它就直接再声明一个final变量,用原变量赋值,然后把新的final变量传给匿名内部类,如:

int numberOfStudents = countStudents();
final int finalNumberOfStudents = numberOfStudents;
button.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
        System.out.println("Number of students is " + finalNumberOfStudents);
    }
}

到此就明白了,Java 8关于闭包的支撑,其实较之前没有实质的变化,只不过编译器帮你做了这个final变量的界说而已。

这部分能够参考《Java 8函数式编程》中第2章第3节的内容。

接口办法默许完成

Java 8中,能够给接口interface,增加一个办法的默许完成,这样在完成此接口时,子类能够挑选从头完成,或许不完成,直接调用此办法即可,从语法上来说,是比较简略的,用default要害字来润饰办法即可,如:

interface Formula {
    double calculate(int a);
    default double sqrt(int a) {
        return Math.sqrt(a);
    }
}
class ComplexFormula implements Formula {
    double calculate(int a) {
         return super.sqrt(real) + super.sqrt(imaginary);
    }
}

这儿面,子类ComplexFormula是能够正常编译和运转的。

留意:接口是支撑多重继承的,比如一个类能够完成多个接口,这就有可能存在接口中有相同的默许办法,最好的处理办法便是子类从头完成一下此办法,然后能够用接口的姓名+super来具体指定父类中的办法。这一具体的规则比较杂乱,能够看《Java 8函数式编程》这本书中的第4章第7节,有比较具体的论说。

别的,需求留意,实际运用中,接口的默许办法并不常用,由于这自身便是比较奇怪的,与开始Java的设计有冲突,接口策重于行为的高档笼统,而笼统类侧重目标的高档笼统(多半触及状况属性)。这东西的呈现首要是为了解决向后兼容,比如说当你一个被广泛运用的接口增加了一个新的办法时,所有完成此接口的类有必要全部要改一遍,要完成此接口,这会影响很多的现存代码,而默许办法便是为了解决这个问题的,给新增加的办法标记为default,就不会影响现存代码了。

这个能够仔细读一下《Java 8函数式编程》中的第4章第6节和第7节的内容。

函数接口

支撑函数式编程范式的言语一般来说呢,会把函数作为语义上的一级类型,比如像Python或许Kotlin都有专门用于声明函数的要害字。别的,需求弄清一下函数的概念,简略来说函数便是给定一些输入,然后给出输出,输出随输入改动而改动,不会发生副作用,也便是不会修改全局变量,不会修改环境变量。且具有幂等性,即针对 同一组输入,多次调用,成果仍是相同的,这便是函数。

关于Java,这事儿就有点难办了,由于前面的版别根本就没有把办法独立成为函数,办法有必要存在于类中。为了支撑函数,函数是函数式编程的基本要素,所以要想支撑函数式编程,有必要以某种方法来支撑函数的界说。Java 8中就提出了函数接口的概念。

函数接口是只要一个笼统办法的接口,这儿有两个要害信息,首要,语义上的类型有必要是一个interface,其次,它只能有一个笼统办法,放在曾经的版别,其实意思便是说只要能一个办法,但还要留意的是前面说到的默许办法。那么这儿的要求便是除了默许办法以外,只能有一个办法

函数接口有必要用*@FunctionalInterface*注解来标示,编译器会对它做特别的重视,一旦有超越1个笼统接口,就会编译报错。为啥要用注解而不是增加要害字(如function),或许创立一级类型(如function interface),意图仍是向后兼容。注解仅需求在编译阶段做一些额定的事情即可,这即完成了扩展,又坚持了兼容性。

前面说到的Lambda表达式有必要是一个函数接口的实例,这样说太笼统了,慢慢来解说下。Lambda是一个匿名函数,能够把它了解为一个目标,它所完成的有必要是一个函数接口。换句话说,只要声明为函数接口的当地,也便是办法的参数类型或许变量的类型要声明为函数接口,只要这儿才能够传入lambda表达式。

接着前面的Formula比如,假设有如下运用场景:

class Number {
    int payload;
    public Number transform(Formula formula) {
         return formula.calculate(payload);
    }
}

现在调用transform办法时假设直接传递lambda,是会报错的:

number.transform(a -> a * a); // won't compile

解决办法,便是要给Formula增加函数接口注解:

@FunctionalInterface
interface Formula {
    double calculate(int a);
    default double sqrt(int a) {
        return Math.sqrt(a);
    }
}

关于函数接口,能够参看《Java 8函数式编程》中第2章第4节和第4章第4节。

常用的函数接口

Java 8 界说了一些十分常用的函数接口,这儿做一下简略的介绍。

Predict

断言,给定一个类型为T的输入,给出boolean的输出(true of false)。一般用于过滤操作之中:

Predict<String> isEmpty = String::isEmpty;
students.stream()
    .filter(name -> !name.isEmpty());

Function<T, R>

通用的函数操作,给定类型为T的输入,回来类型为R的输出,一般用于map之中:

Function<String, int> length = name -> name.length();

其实,Predict可视为一种特殊的Function,它的回来类型是boolean。

Consumer

消费类型为T的目标,无输出,作为调用链的终点,一般用于生成终值,如前面比如中传给button的lambda就一个Consumer。

Supplier

回来一个类型为T的目标,也即生产者,一般都是用于工厂办法,用来生成新的目标。

UnaryOperator

一元操作符,输入类型是T的目标,回来类型是T的目标:

UnaryOperator<Integer> square = x -> x * x;

BinaryOperator

二元操作符,输入参数是类型同为T的a和b两个参数,输出是一个类型为T的成果:

BinaryOperator<String> join = (first, second) -> first + ", " + second;

这儿比如不是许多,由于独自写这些函数接口的lambda不太好写,且意义不行实用,会在后边结合Stream API,给出更多示例。

Optional

这个类用于封装可能为空的目标,以更好的处理null的状况,它加强了类型检查(null自身是没有类型的),以及运用时的空值检查,所以能够必定程度上避免NullPointerException的呈现。

拥抱新时代的Java

先来看一下它的简略运用办法:

Optional<String> a = Optional.of("a");
System.out.println(a.get()); // a
Optional empty = Optional.empty(); // 回来一个为空的目标
System.out.println(empty.isPresent()); // false
System.out.println(empty.orElse("b"); // b
System.out.println(empty.orElseGet(() -> "c")); // c

前面2行好了解了,第3行创立一个为空的Optional目标,它的isPresent会回来false,orElse是说假设为空时能够回来一个默许值『b』,而最后一行也能够为默许值提供一个Supplier以在为空的时候发生一个值。

经过这几个小比如能够看出Optional的用处,它能够比较好的封装目标,并提前界说值不存在时的应对状况,能够必定程序上削减NPE。

不过,这个东西关于杂乱项目来说效用不会太大,假设你到处判断isPresent,其实跟检测== null也没有本质区别。实际项目中很多的NPE来自于多线程环境共享成员变量,这种状况下Optional也救不了你。

要想发挥这东西的最大效用,需求从设计角度尽可能的削减变量共享,尽可能的缩小变量作用域,再合作默许值或许默许值的Suppiier,多管齐下,才能有用的避免NPE。

办法引证

函数式编程,函数要是语义层面的一级类型,变量或许参数的类型能够是函数,前面说到了在Java 8中代表函数类型便是函数接口。

那么,当传递具体函数体的时候,我们一向在运用lambda表达式,但这并不是合适所有场景,比如说我已经有了一个类的办法,彻底契合函数接口的办法签名,莫非还非要写一个lambda吗?

button.addActionListener(event -> System.out.println(event));
Predict<String> empty = str -> str.isEmpty();
Function<Artist, String> namer = artist -> artist.getName();

这显然太啰嗦了,这种状况下,能够直接用办法引证,来把已有的办法传递过去,形式是类名::办法名,用办法引证重写上面的几个小比如:

button.addActionListener(System.out::println);
Predict<String> empty = String::isEmpty;
Function<Artist, String> namer = Artist::getName;

简洁了许多吧,不光能够复用已有的办法,简洁明了,而且也省去创立一个lambda目标。必定要留意的便是要用办法的姓名,不能加括号,由于加了括号,在语义上便是对函数的调用了,引证的便是该办法的回来值,除非这个办法的回来值是一个函数接口实例(lambda或许一个办法引证)。

除了惯例办法能够用作引证以外,还能够对结构办法进行引证,格式是类名::new,如

Artist::new; // 适当于  (name, nationality) -> new Artist(name, nationality);

能够参看《Java 8函数式编程》第5章第1节的内容。

Stream API

总算到了最为重要的特性了,为了更进一步的支撑函数式编程,Java 8新增了Stream API,它是针对集合类型(List,Map和Set等)函数式操作的支撑,以更好的把行为与遍历分离。先来看一下小比如:

比如有这样一个列表:

List<String> giants = List.of("Apple", "Google", "Microsoft", "Facebook", "Tesla");

想简略遍历一下,曾经这么写:

 for (String item : giants) {
     System.out.println(item);
 }

但,现在只需求这样写就能够了:

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

是不是很清新,这便是典型的函数式写法,你可能会说就这?客官别急,这仅仅前戏,后边还有更影响的。

拥抱新时代的Java

留意:这儿必定要与I/O stream区别开来,彻底是两个东西。Stream API是针对 集合操作的函数式支撑。

函数式编程中心元素是函数,它经过对函数的各种组合得到终究的成果,最为典型的便是流式调用,把函数串连起来,或许叫做链式调用,让数据在函数链中流动,终究得到希望的成果。最为经典的函数式『三板斧』便是过滤(filter),转化(map)和折叠(也称化约,英文是reduce),这是所有函数式程序的基本结构单元。能够参看《函数式编程思想》这本书的第2章,有比较具体的评论。

拥抱新时代的Java

杂乱的实例

为了更好的演示Java 8的Stream API,以及综合运用函数式办法,本文剩余部分,将根据Brooklyn的球员技能核算信息操作为根底的实例。球队中有多名球员,每个球员有一些基本信息和一组比赛技能核算,现在教练需求对信息做一些核算。根底的类型是球员包含其基本信息和技能核算,如下:

public class Player {
    private final String firstName;
    private final String lastName;
    private final String community;
    private final int points;
    private final int rebounds;
    private final float fieldGoal;
    @Override
    public String toString() {
        return "'" + firstName +
                ", " + lastName + '\'' +
                ", from '" + community + '\'' +
                ", scores=" + points +
                ", rebounds=" + rebounds +
                String.format(", fieldGoal=%.2f%%", fieldGoal * 100.f);
    }
    private Player(String firstName, String lastName, String community, int scores, int rebounds, float fieldGoal) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.community = community;
        this.points = scores;
        this.rebounds = rebounds;
        this.fieldGoal = fieldGoal;
    }
    public static class Builder {
        private String firstName;
        private String lastName;
        private String community;
        private int scores;
        private int  rebounds;
        private float fieldGoal;
        public Builder firstName(String firstName) {
            this.firstName = firstName;
            return this;
        }
        public Builder lastName(String lastName) {
            this.lastName = lastName;
            return this;
        }
        public Builder community(Supplier<String> communitySupplier) {
            community = communitySupplier.get();
            return this;
        }
        public Builder points(Supplier<Integer> pointsSupplier) {
            scores = pointsSupplier.get();
            return this;
        }
        public Builder rebounds(Supplier<Integer> reboundsSupplier) {
            rebounds = reboundsSupplier.get();
            return this;
        }
        public Builder fieldGoal(Supplier<Float> fgSupplier) {
            fieldGoal = fgSupplier.get();
            return this;
        }
        public Player build() {
            return new Player(firstName, lastName, community, scores, rebounds, fieldGoal);
        }
    }
}

再有便是球队了,便是针对球员们的操作的当地,首要,需求生成数据:

public class Brooklyn {
    public static void main(String[] args) {
        List<Player> players = generatePlayers();
    }
    private static List<Player> generatePlayers() {
        List<String> names = List.of(
                "James Harden", "Kevin Durant", "Kyrie Irving", "Nic Clyxton",
                "Kessler Edwards", "Bruce Brown", "LaMarcus Aldridge", "Blake Griffin"
        );
        List<String> communities = List.of("The Bronx", "Brooklyn", "Manhattan", "Queens", "Staten Island");
        Random random = new Random(System.currentTimeMillis());
        return names.stream()
                .map(name -> {
                    String[] parts = name.split(" ");
                    return new Player.Builder().firstName(parts[0])
                            .lastName(parts[1])
                            .community(() -> {
                                int index = random.nextInt(communities.size());
                                return communities.get(index);
                            })
                            .points(() -> random.nextInt(61))
                            .rebounds(() -> random.nextInt(31))
                            .fieldGoal(() -> random.nextFloat())
                            .build();
                })
                .collect(Collectors.toList());
    }
}

这儿为了便利运用了一个Builder Pattern。别的,创立数据的进程中,其实用到上面说到的很多知识点,如Supplier的运用,以及闭包和办法引证。全体并不难,能够仔细读一读比如中的代码。

Stream根底操作

先来看一下Stream的根底操作,包含filter,map和reduce,以及sort和match,不准备说太多的废话,将以实例操作为主线来解说。

forEach

也即遍历,十分便利:

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

输出会是:

‘James, Harden’, from ‘Brooklyn’, scores=11, rebounds=24, fieldGoal=10.62%
‘Kevin, Durant’, from ‘Queens’, scores=48, rebounds=4, fieldGoal=47.16%
‘Kyrie, Irving’, from ‘Staten Island’, scores=17, rebounds=21, fieldGoal=86.05%
‘Nic, Clyxton’, from ‘Queens’, scores=43, rebounds=11, fieldGoal=99.66%
‘Kessler, Edwards’, from ‘The Bronx’, scores=55, rebounds=12, fieldGoal=46.78%
‘Bruce, Brown’, from ‘Queens’, scores=10, rebounds=20, fieldGoal=77.51%
‘LaMarcus, Aldridge’, from ‘Manhattan’, scores=35, rebounds=22, fieldGoal=98.18%
‘Blake, Griffin’, from ‘Brooklyn’, scores=3, rebounds=4, fieldGoal=38.06%

这个运用起来适当简略,forEach接纳一个Consumer,别的需求留意的是forEach不会回来一个Stream目标,所以不能在这以后再持续增加链了。它一般作为整个链路的终端,消费终究成果。

留意:由于数据生成进程中运用了一些随机数,所以运转成果可能会不同。

filter

想看看哪些球员,命中率超越五成:

       players.stream()
                .filter(player -> player.getFieldGoal() >= 0.5f)
                .forEach(System.out::println);

输出:

‘James, Harden’, from ‘Brooklyn’, scores=6, rebounds=22, fieldGoal=95.02%
‘Kevin, Durant’, from ‘The Bronx’, scores=37, rebounds=17, fieldGoal=78.81%
‘Bruce, Brown’, from ‘Queens’, scores=26, rebounds=23, fieldGoal=57.35%
‘LaMarcus, Aldridge’, from ‘The Bronx’, scores=35, rebounds=4, fieldGoal=59.75%

filter仍是很简单了解的,它接纳一个Predict,然后回来Stream中契合条件的元素,也即Predict中是true的。

map

转化,把一种数据类型转化为别的一种类型,其实从创立数据的办法generatePlayers中就能够看到了,是把String转化为Player,根据姓名生成数据目标。

sort

接着前面的比如,把输出按命中率从高到低排个序吧:

    players.stream()
                .filter(player -> player.getFieldGoal() >= 0.5f)
                .sorted((a, b) -> (int) (b.getFieldGoal()*100 - a.getFieldGoal()*100))
                .forEach(System.out::println);

输出:

‘Nic, Clyxton’, from ‘Queens’, scores=34, rebounds=17, fieldGoal=93.82%
‘Kyrie, Irving’, from ‘Brooklyn’, scores=37, rebounds=16, fieldGoal=82.95%
‘LaMarcus, Aldridge’, from ‘Staten Island’, scores=43, rebounds=10, fieldGoal=52.94%

flatMap

map是把一种数据类型转化为别的一各类型,然后让其在链式中流动,flatMap是更为杂乱的操作,它是先做map再做flat,想当于把二维的Stream展平成为一维的Stream,传给flatMap的lambda有必要回来一个Stream,来看个比如:

     public static Stream<String> queryEmail(String name) {
         return Stream.of(name + "@brooklyn.nets");
     }
     players.stream()
            .flatMap(player -> queryEmail(player.getLastName()))
            .forEach(System.out::println);

输出:

Harden@brooklyn.nets
Durant@brooklyn.nets
Irving@brooklyn.nets
Clyxton@brooklyn.nets
Edwards@brooklyn.nets
Brown@brooklyn.nets
Aldridge@brooklyn.nets
Griffin@brooklyn.nets

这儿的获取到的Email是别的一个Stream,所以这儿有必要用flatMap,也即当把player转化为Email后,有必要要再flat,变成开始的链中的目标。

及时求值

前面讲的操作都是慵懒求值的,它们都是回来一个Stream,而Stream自身仅是封装操作,其实并没有生成终究值。但有些操作是能够生成终究值的,便是把整个链路的值进行运算,然后生成终究的值,但这个值不再是Stream了,也便是说及时求值操作只能作为链式的终点。

留意:慵懒求值是函数式编程的一个概念,它的首要意图是将行为与成果分离开来,以便利并行化处理。具体能够参看《函数式编程思想》书中的第4章,有具体的论说。

count

核算一下来自『Queens』的球员数量:

        long fromQueens = players.stream()
                .filter(player -> player.getCommunity().equals("Queens"))
                .count();
        System.out.println(fromQueens);
        // Output is: 2

match

查看Stream的元素中是否有匹配的条件的,有any意即任意元素有了匹配,all所有,none没有(适当于not all):

        boolean fromQueens = players.stream()
                .anyMatch(player -> player.getCommunity().equals("Queens"));
        System.out.println(fromQueens);
        // 是否有人来自于Queens,true
        boolean fromQueens = players.stream()
                .allMatch(player -> player.getCommunity().equals("Queens"));
        System.out.println(fromQueens);
        // 所有人都来自Queens,false
        boolean fromQueens = players.stream()
                .noneMatch(player -> player.getCommunity().equals("Queens"));
        System.out.println(fromQueens);
        // 所有人都来自非Queens,false

reduce

折叠或许叫作化约,有些言语也称之为fold,它接纳两个参数,榜首个是初始值,然后是一个二元操作符BinaryOperator,二元操作的榜首个参数是截止目前的成果,第二个参数是当前的元素,然后针对每个元素进行翻滚执行这个二元操作符。这么说有点难于了解,我们来个,核算球员们的总得分吧:

        int totalPoints = players.stream()
                .map(Player::getPoints)
                .reduce(0, (a, b) -> a + b);
        System.out.println(totalPoints);
        // output is 247

再来核算均匀命中率:

        Optional<Float> averageFieldGoal = players.stream()
                .map(Player::getFieldGoal)
                .reduce((a, b) -> (a + b) / 2.f);
        System.out.println(averageFieldGoal.get());
        // Output is 0.40

假设没有初始值,或许初始值是0(针对数值时),为空时(针对目标),那么能够省掉reduce的第1个参数,这时它会用第1个元素用作初始值。

max和min

寻找最少的篮板数的球员:

        Optional<Player> minRebound = players.stream()
                        .min((a, b) -> a.getRebounds() - b.getRebounds());
        System.out.println(minRebound.get());

输出:

‘Kessler, Edwards’, from ‘Staten Island’, scores=8, rebounds=2, fieldGoal=97.53%

寻找命中率最高的球员:

        Optional<Player> bestShooter = players.stream()
                        .max((a, b) -> (int) (a.getFieldGoal()*100f - b.getFieldGoal()*100f));
        System.out.println(bestShooter.get());

输出:

‘Bruce, Brown’, from ‘The Bronx’, scores=25, rebounds=15, fieldGoal=88.19%

留意:reduce无初始值时,max和min回来的都是Optional,由于可能会取不到具体的值。

This is just the beginning

学无止境,Stream API还有许多高档的东西,以及Java 8的新特性也还有许多,还有待后边持续深入学习。

Android SDK的支撑状况

进入智能手机年代和移动互联网年代,Java曾一度衰败,好在安卓的官方开发言语是Java,这也让Java没有被丢掉,虽然现在谷歌力推Kotlin,不过Java仍是安卓 开发的首选言语,且仍在被广泛运用。不过,安卓的Java,并不是Oracle的Java SE,而是根据Apache开源的OpenJDK,这货自Java 1.6版别以后就没怎么更新,而作为downstream的安卓,更是一向停留在1.6的版别上面,这也导致了安卓开发人猿一向未能跟紧Java的开展,当然 这也是Kotlin自推出以来大受安卓开发人猿欢迎的原因。好在谷歌也在推动,它是以打包插件的方法来支撑Java 7和Java 8的部分子集。现在AGP(Android Gradle Plugin)4.0以上的版别,是能够运用大部分Java 8的特性的,前面叙述的lambda,Optional,函数接口和Stream等都是能够直接运用的,只要把AGP的版别升级到4.0以上,sourceCompatibility挑选VERSION_1_8,就能够了。

能够参看官方文档。而这篇文章适当不错的阐述一些具体的原因,能够仔细读一下。

优质书籍

编程范式的学习曲线都是十分陡峭的,函数式编程注重的是行为的笼统,以行为(函数)为榜首要从来构建解决方案,这需求思想的转变。并不是说你用了一个lambda便是函数式编程了。因而需求系统化的学习。而系统化的学习,最好的方法便是去啃书(没说看,是要啃书)。

下面列出关于函数式编程,特别是用Java 8进行实践函数式编程的几本非优质的书籍:

Functional Thinking

中译名是《函数式编程思想》,是由Neal Ford出品的佳作,专门叙述怎么Thinking in Functional Programming。这本书也不是很厚,十分值得看。由于是要点解说函数式编程思想 的,所以它用了Java/Scala和Groovy,而且Java的版别还不是Java 8的。

这儿也要说一下,编程范式跟言语是否直接支撑没有关系,它更是一种思想笼统办法,比如用C也能写出彻底契合面向目标的代码;用Java 7曾经的版别也能写出函数式程序。

Java 8 Lambdas: Functional Programming For The Masses

中译名是《Java 8函数式编程》,由Richard Warburton写的。里边有丰厚的实例和练习题,也不厚,专注于解说怎么用Java 8来实践函数式编程。

Java 8 in Action

中译名《Java 8实战》,由三位作者Raoul-Gabriel Urma, Mario Fusco, and Alan Mycroft合著。内容其实与前面那个差不多,但略有不同,这本书是要点解说Java 8的新特性的,当然很多篇幅也是讲用Java 8实践函数式编程的(由于Java 8最重要的改善便是对函数式编程的支撑),但还有其他的内容。而且这本书较厚,里边各种知识点解说比较具体。

参考资料

  • A Guide to Java Streams in Java 8: In-Depth Tutorial With Examples
  • Java8 新特性教程
  • [译] 一文带你玩转 Java8 Stream 流,从此操作集合 So Easy
  • Java8 Stream彻底运用指南
  • The Java 8 Stream API Tutorial