新特性Lambda表达式和Function函数式接口编程
目录
1、lambda在JSR（Java Specification Requests）
2、lambda在JLS（Java LanguageSpecifications）
前言：jdk1.8推出了lambda表达式和函数式接口编程，本文主要从java中JSR需求规范到JLS语言规范再到JVM规范，介绍lambda和function。
1、lambda在JSR（Java Specification Requests）
首先，要想了解lambda，从需求规范开始，我们从JSR需求中可以看到，JSR335即为lambda的需求规范，我们可以进行download，打开如下图所示：
如上，Overview中，概述定义了如下几点功能：
- Lambda expressions and method references——lambda表达式和方法引用
- Enhanced type inference and target typing——增强类型推断和目标类型转换
- Default and static methods in interfaces——在接口里默认和静态的方法
这三个新的features，规定了我们的lambda；jdk中util下提供了新的API，还有，用的比较多的util下的stream，关于function如下图所示：
Contents内容包括如下三点：
- 规范更改，主要是对Java语言规范的更新，并支持对Java虚拟机规范（此处）和Java对象序列化规范（此处）的更改
- Java SE API更新摘要
- 对新语言和库功能的非正式（非规范性）概述
2、lambda在JLS（Java LanguageSpecifications）
在JLS规范中，我们可以看一下lambda表达式的规范定义：
定义了，lambda表达式在赋值上下文、调用上下文、强制类型转换上下文，否则编译器将报错。
表达式的求值将产生一个function接口实例。表达式的求值不一定导致表达式主体的执行，相反，这可能在以后调用功能接口的适当方法时发生。
接下来是，Lambda Parameters和 Lambda Body，显式与隐式参数类型；如果形式参数具有推断的类型，则这些类型是从lambda表达式所针对的功能接口类型派生的。
更多的细节，就不在此赘述了。有兴趣的同学可以自行官网查看。
3、lambda表达式在jvm规范
比如我们针对其中一个class查看其字节码文件，javap -v Filtering.class。
可以很明显的看出，函数式接口在字节码底层是InvokeDynamic，通过下面的jdk源码中可以看出，底层是newInvokeDynamicItem，当class build时 放入到常量池中。
invokedynamic 这个操作码的执行方法会关联到一个动态调用点对象（Call Site object），这个call site 对象会指向一个具体的bootstrap 方法（方法的二进制字节流信息在BootstrapMethods属性表中）的执行，invokedynamic指令的调用会有一个独特的调用链，不像其他指令会直接调用方法，在实际的运行过程也相对更加复杂。
/**
* Adds an invokedynamic reference to the constant pool of the class being
* build. Does nothing if the constant pool already contains a similar item.
* <i>This method is intended for {@link Attribute} sub classes, and is
* normally not needed by class generators or adapters.</i>
*
* @param name
* name of the invoked method.
* @param desc
* descriptor of the invoke method.
* @param bsm
* the bootstrap method.
* @param bsmArgs
* the bootstrap method constant arguments.
*
* @return a new or an already existing invokedynamic type reference item.
*/
Item newInvokeDynamicItem(final String name, final String desc,
final Handle bsm, final Object... bsmArgs) {
// cache for performance
ByteVector bootstrapMethods = this.bootstrapMethods;
if (bootstrapMethods == null) {
bootstrapMethods = this.bootstrapMethods = new ByteVector();
}
int position = bootstrapMethods.length; // record current position
通过如下的方法执行，// (site.)invokedynamic(a*):R => mh = site.getTarget(); mh.invokeBasic(a*)。在栈针底层// NA, //INVOKEDYNAMIC, // visitInvokeDynamicInsn。
在底层jvm中generateOopMap.cpp，可以看如下图。
包括在Frame.java中的压栈。
case Opcodes.INVOKEDYNAMIC:
pop(item.strVal2);
push(cw, item.strVal2);
break;更多的细节就不再赘述了，有兴趣的同学可以自行了解深入。
4、Stream流
流的定义：从支持数据处理操作的源生成的元素序列
Stream API 基本都是返回Stream本身，这样多个操作可以串联成一个管道， 如同流式风格（fluent style）。 这样做可以对操作进行优化， 比如延迟执行(laziness)和短路( short-circuiting)
4.1 两种stream流
•stream() − 为集合创建串行流。
•parallelStream() − 为集合创建并行流。
4.2 简洁遍历
stream提供了一个内部遍历的方式forEach()，通过forEach可以大大简化集合遍历的代码
4.3 过滤
stream提供了一个用于数据过滤的方法filter()，与stream的其他API配合使用可以简单的实现数据过滤
public class Filtering {
public static void main(String...args){
//过滤出素菜
List<Dish> vegetarianMenu =
menu.stream()
//filter参数为谓词 也就是boolean类型
.filter(Dish::isVegetarian) //method reference
.collect(toList());
vegetarianMenu.forEach(System.out::println);
// 过滤指定的元素 去重
List<Integer> numbers = Arrays.asList(1, 2, 1, 3, 3, 2, 4);
numbers.stream()
.filter(i -> i % 2 == 0)
.distinct()//去重
.forEach(System.out::println);
//limit 截断流
List<Dish> dishesLimit3 =
menu.stream()
.filter(d -> d.getCalories() > 300)
.limit(3)
.collect(toList());
dishesLimit3.forEach(System.out::println);
//skip：跳过n个元素
List<Dish> dishesSkip2 =
menu.stream()
.filter(d -> d.getCalories() > 300)
.skip(2)
.collect(toList());
dishesSkip2.forEach(System.out::println);
}
public static final List<Dish> menu =
Arrays.asList( new Dish("pork", false, 800, Type.MEAT),
new Dish("beef", false, 700, Type.MEAT),
new Dish("chicken", false, 400, Type.MEAT),
new Dish("french fries", true, 530, Type.OTHER),
new Dish("rice", true, 350, Type.OTHER),
new Dish("season fruit", true, 120, Type.OTHER),
new Dish("pizza", true, 550, Type.OTHER),
new Dish("prawns", false, 400, Type.FISH),
new Dish("salmon", false, 450, Type.FISH));
}4.4 映射
stream提供了一个用于数据映射的方法map()，与stream的其他API配合使用可以简单的实现数据映射
public class Mapping {
public static void main(String...args){
// map
List<String> dishNames = menu.stream()
.map(Dish::getName)
// .map(dish -> dish.getName())
.collect(toList());
System.out.println(dishNames);
// map
List<String> words = Arrays.asList("Hello", "World");
List<Integer> wordLengths = words.stream()
.map(String::length)
.collect(toList());
System.out.println(wordLengths);
// flatMap
words.stream()
//切割成单个词
.flatMap((String line) -> Arrays.stream(line.split("")))
.distinct()//去重
.forEach(System.out::println);
// flatMap
List<Integer> numbers1 = Arrays.asList(1,2,3,4,5);
List<Integer> numbers2 = Arrays.asList(6,7,8);
List<int[]> pairs =
numbers1.stream()
//两个list中纵向两两组合成为一个二维数组
.flatMap((Integer i) -> numbers2.stream().map((Integer j) -> new int[]{i, j})
)
//过滤二维数组 两列之和为3的倍数
.filter(pair -> (pair[0] + pair[1]) % 3 == 0)
.collect(toList());
pairs.forEach(pair -> System.out.println("(" + pair[0] + ", " + pair[1] + ")"));
}
}4.5 查找元素
public class Finding {
public static void main(String...args){
if(isVegetarianFriendlyMenu()){
System.out.println("Vegetarian friendly");
}
System.out.println(isHealthyMenu());
System.out.println(isHealthyMenu2());
Optional<Dish> dish = findVegetarianDish();
dish.ifPresent(d -> System.out.println(d.getName()));
}
//相当于||
private static boolean isVegetarianFriendlyMenu(){
return menu.stream().anyMatch(Dish::isVegetarian);
}
//相当于 &&
private static boolean isHealthyMenu(){
return menu.stream().allMatch(d -> d.getCalories() < 1000);
}
//相当于 !=
private static boolean isHealthyMenu2(){
return menu.stream().noneMatch(d -> d.getCalories() >= 1000);
}
//匹配任何一个 适用于并发流执行
private static Optional<Dish> findVegetarianDish(){
return menu.stream().filter(Dish::isVegetarian).findAny();
}
}4.6 reduce方法
reduce方法将流归约成一个值。用函数式编程语言的术语来说，这称为折叠（fold）public class Reducing {
public static void main(String...args){
List<Integer> numbers = Arrays.asList(3,4,5,1,2);
//语法 reduce(起点, 算法规则);
int sum = numbers.stream().reduce(0, (a, b) -> a + b);
System.out.println(sum);
int sum2 = numbers.stream().reduce(0, Integer::sum);
System.out.println(sum2);
int max = numbers.stream().reduce(0, (a, b) -> Integer.max(a, b));
System.out.println(max);
Optional<Integer> min = numbers.stream().reduce(Integer::min);
min.ifPresent(System.out::println);
int calories = menu.stream()
.map(Dish::getCalories)
.reduce(0, Integer::sum);
System.out.println("Number of calories:" + calories);
}
}4.7 stream实战
public class PuttingIntoPractice {
public static void main(String...args){
Trader raoul = new Trader("Raoul", "Cambridge");
Trader mario = new Trader("Mario","Milan");
Trader alan = new Trader("Alan","Cambridge");
Trader brian = new Trader("Brian","Cambridge");
List<Transaction> transactions = Arrays.asList(
new Transaction(brian, 2011, 300),
new Transaction(raoul, 2012, 1000),
new Transaction(raoul, 2011, 400),
new Transaction(mario, 2012, 710),
new Transaction(mario, 2012, 700),
new Transaction(alan, 2012, 950)
);
// Query 1: Find all transactions from year 2011 and sort them by value (small to high).
List<Transaction> tr2011 = transactions.stream()
.filter(transaction -> transaction.getYear() == 2011)
.sorted(comparing(Transaction::getValue))
.collect(toList());
System.out.println(tr2011);
// Query 2: What are all the unique cities where the traders work?
List<String> cities =
transactions.stream()
.map(transaction -> transaction.getTrader().getCity())
.distinct()
.collect(toList());
System.out.println(cities);
// Query 3: Find all traders from Cambridge and sort them by name.
List<Trader> traders =
transactions.stream()
.map(Transaction::getTrader)
.filter(trader -> trader.getCity().equals("Cambridge"))
.distinct()
.sorted(comparing(Trader::getName))
.collect(toList());
System.out.println(traders);
// Query 4: Return a string of all traders’ names sorted alphabetically.
String traderStr =
transactions.stream()
.map(transaction -> transaction.getTrader().getName())
.distinct()
.sorted()
.reduce("", (n1, n2) -> n1 + n2);
System.out.println(traderStr);
// Query 5: Are there any trader based in Milan?
boolean milanBased =
transactions.stream()
.anyMatch(transaction -> transaction.getTrader()
.getCity()
.equals("Milan")
);
System.out.println(milanBased);
// Query 6: Update all transactions so that the traders from Milan are set to Cambridge.
transactions.stream()
.map(Transaction::getTrader)
.filter(trader -> trader.getCity().equals("Milan"))
.forEach(trader -> trader.setCity("Cambridge"));
System.out.println(transactions);
// Query 7: What's the highest value in all the transactions?
int highestValue =
transactions.stream()
.map(Transaction::getValue)
.reduce(0, Integer::max);
System.out.println(highestValue);
}
}public class Trader {
private String name;
private String city;
public Trader(String n, String c){
this.name = n;
this.city = c;
}
public String getName(){
return this.name;
}
public String getCity(){
return this.city;
}
public void setCity(String newCity){
this.city = newCity;
}
@Override
public String toString(){
return "Trader:"+this.name + " in " + this.city;
}
}public class Transaction {
private Trader trader;
private int year;
private int value;
public Transaction(Trader trader, int year, int value)
{
this.trader = trader;
this.year = year;
this.value = value;
}
public Trader getTrader(){
return this.trader;
}
public int getYear(){
return this.year;
}
public int getValue(){
return this.value;
}
@Override
public String toString(){
return "{" + this.trader + ", " +
"year: "+this.year+", " +
"value:" + this.value +"}";
}
}5、Collectors收集之术
Collectors 类实现了很多归约操作，例如将流转换成集合和聚合元素。Collectors 可用于返回列表或字符串
5.1 Grouping
多级分组、各种复杂分组
public class Grouping {
enum CaloricLevel { DIET, NORMAL, FAT };
public static void main(String... args) {
System.out.println("Dishes grouped by type: " + groupDishesByType());
System.out.println("Dish names grouped by type: " + groupDishNamesByType());
System.out.println("Dish tags grouped by type: " + groupDishTagsByType());
System.out.println("Caloric dishes grouped by type: " + groupCaloricDishesByType());
System.out.println("Dishes grouped by caloric level: " + groupDishesByCaloricLevel());
System.out.println("Dishes grouped by type and caloric level: " + groupDishedByTypeAndCaloricLevel());
System.out.println("Count dishes in groups: " + countDishesInGroups());
System.out.println("Most caloric dishes by type: " + mostCaloricDishesByType());
System.out.println("Most caloric dishes by type: " + mostCaloricDishesByTypeWithoutOprionals());
System.out.println("Sum calories by type: " + sumCaloriesByType());
System.out.println("Caloric levels by type: " + caloricLevelsByType());
}
//给groupingBy方法传递了一个Function（以方法引用的形式），它提取了流中每一道Dish的Dish.Type。
//我们把这个Function叫作分类函数，因为它用来把流中的元素分成不同的组
private static Map<Dish.Type, List<Dish>> groupDishesByType() {
return menu.stream().collect(groupingBy(Dish::getType));
}
//多级分组，可以使用一个由双参数版本的Collectors.groupingBy工厂方法创建的收集器，
//除了普通的分类函数之外，还可以接受collector类型的第二个参数。
private static Map<Dish.Type, List<String>> groupDishNamesByType() {
return menu.stream().collect(groupingBy(Dish::getType, mapping(Dish::getName, toList())));
}
private static Map<Dish.Type, Set<String>> groupDishTagsByType() {
return menu.stream().collect(
groupingBy(Dish::getType,
flatMapping(dish -> dishTags.get( dish.getName() ).stream(), toSet())
)
);
}
private static Map<Dish.Type, List<Dish>> groupCaloricDishesByType() {
// return menu.stream().filter(dish -> dish.getCalories() > 500).collect(groupingBy(Dish::getType));
return menu.stream().collect(groupingBy(Dish::getType, filtering(dish -> dish.getCalories() > 500, toList())));
}
private static Map<CaloricLevel, List<Dish>> groupDishesByCaloricLevel() {
return menu.stream().collect(
groupingBy(dish -> {
if (dish.getCalories() <= 400) return CaloricLevel.DIET;
else if (dish.getCalories() <= 700) return CaloricLevel.NORMAL;
else return CaloricLevel.FAT;
} ));
}
private static Map<Dish.Type, Map<CaloricLevel, List<Dish>>> groupDishedByTypeAndCaloricLevel() {
return menu.stream().collect(
groupingBy(Dish::getType,
groupingBy((Dish dish) -> {
if (dish.getCalories() <= 400) return CaloricLevel.DIET;
else if (dish.getCalories() <= 700) return CaloricLevel.NORMAL;
else return CaloricLevel.FAT;
} )
)
);
}
private static Map<Dish.Type, Long> countDishesInGroups() {
return menu.stream().collect(groupingBy(Dish::getType, counting()));
}
private static Map<Dish.Type, Optional<Dish>> mostCaloricDishesByType() {
return menu.stream().collect(
groupingBy(Dish::getType,
reducing((Dish d1, Dish d2) -> d1.getCalories() > d2.getCalories() ? d1 : d2)));
}
private static Map<Dish.Type, Dish> mostCaloricDishesByTypeWithoutOprionals() {
return menu.stream().collect(
groupingBy(Dish::getType,
collectingAndThen(
reducing((d1, d2) -> d1.getCalories() > d2.getCalories() ? d1 : d2),
Optional::get)));
}
private static Map<Dish.Type, Integer> sumCaloriesByType() {
return menu.stream().collect(groupingBy(Dish::getType,
summingInt(Dish::getCalories)));
}
//自定义内部实现
private static Map<Dish.Type, Set<CaloricLevel>> caloricLevelsByType() {
return menu.stream().collect(
groupingBy(Dish::getType, mapping(
dish -> {
if (dish.getCalories() <= 400) return CaloricLevel.DIET;
else if (dish.getCalories() <= 700) return CaloricLevel.NORMAL;
else return CaloricLevel.FAT;
},
toSet())));
}
}public class Dish {
private final String name;
private final boolean vegetarian;
private final int calories;
private final Type type;
public Dish(String name, boolean vegetarian, int calories, Type type) {
this.name = name;
this.vegetarian = vegetarian;
this.calories = calories;
this.type = type;
}
public String getName() {
return name;
}
public boolean isVegetarian() {
return vegetarian;
}
public int getCalories() {
return calories;
}
public Type getType() {
return type;
}
public enum Type { MEAT, FISH, OTHER }
@Override
public String toString() {
return name;
}
public static final List<Dish> menu =
Arrays.asList( new Dish("pork", false, 800, Type.MEAT),
new Dish("beef", false, 700, Type.MEAT),
new Dish("chicken", false, 400, Type.MEAT),
new Dish("french fries", true, 530, Type.OTHER),
new Dish("rice", true, 350, Type.OTHER),
new Dish("season fruit", true, 120, Type.OTHER),
new Dish("pizza", true, 550, Type.OTHER),
new Dish("prawns", false, 400, Type.FISH),
new Dish("salmon", false, 450, Type.FISH));
public static final Map<String, List<String>> dishTags = new HashMap<>();
static {
dishTags.put("pork", asList("greasy", "salty"));
dishTags.put("beef", asList("salty", "roasted"));
dishTags.put("chicken", asList("fried", "crisp"));
dishTags.put("french fries", asList("greasy", "fried"));
dishTags.put("rice", asList("light", "natural"));
dishTags.put("season fruit", asList("fresh", "natural"));
dishTags.put("pizza", asList("tasty", "salty"));
dishTags.put("prawns", asList("tasty", "roasted"));
dishTags.put("salmon", asList("delicious", "fresh"));
}
}5.2 partitioningBy收集器
partitioningBy收集器：由一个谓词（返回一个布尔值的函数）作为分类函数，它称分区函数。分区的优势分区：在于保留了分区函数返回true或false的两套流元素列表，可以二次分区public class Partitioning {
public static void main(String... args) {
System.out.println("Dishes partitioned by vegetarian: " + partitionByVegeterian());
System.out.println("Vegetarian Dishes by type: " + vegetarianDishesByType());
System.out.println("Most caloric dishes by vegetarian: " + mostCaloricPartitionedByVegetarian());
}
private static Map<Boolean, List<Dish>> partitionByVegeterian() {
return menu.stream().collect(partitioningBy(Dish::isVegetarian));
}
private static Map<Boolean, Map<Dish.Type, List<Dish>>> vegetarianDishesByType() {
return menu.stream().collect(partitioningBy(Dish::isVegetarian, groupingBy(Dish::getType)));
}
//素菜和非素菜中卡路里最大的map集合
//演示二次分区
private static Object mostCaloricPartitionedByVegetarian() {
return menu.stream().collect(
partitioningBy(Dish::isVegetarian,
collectingAndThen(
maxBy(comparingInt(Dish::getCalories)),
Optional::get)));
}
}5.3 reduce
public class Reducing {
public static void main(String... args) {
System.out.println("Total calories in menu: " + calculateTotalCalories());
System.out.println("Total calories in menu: " + calculateTotalCaloriesWithMethodReference());
System.out.println("Total calories in menu: " + calculateTotalCaloriesWithoutCollectors());
System.out.println("Total calories in menu: " + calculateTotalCaloriesUsingSum());
}
private static int calculateTotalCalories() {
return menu.stream().collect(reducing(0, Dish::getCalories, (Integer i, Integer j) -> i + j));
}
private static int calculateTotalCaloriesWithMethodReference() {
return menu.stream().collect(reducing(0, Dish::getCalories, Integer::sum));
}
private static int calculateTotalCaloriesWithoutCollectors() {
return menu.stream().map(Dish::getCalories).reduce(Integer::sum).get();
}
private static int calculateTotalCaloriesUsingSum() {
return menu.stream().mapToInt(Dish::getCalories).sum();
}
}5.4 Summarizing
public class Summarizing {
public static void main(String... args) {
System.out.println("Nr. of dishes: " + howManyDishes());
System.out.println("The most caloric dish is: " + findMostCaloricDish());
System.out.println("The most caloric dish is: " + findMostCaloricDishUsingComparator());
System.out.println("Total calories in menu: " + calculateTotalCalories());
System.out.println("Average calories in menu: " + calculateAverageCalories());
System.out.println("Menu statistics: " + calculateMenuStatistics());
System.out.println("Short menu: " + getShortMenu());
System.out.println("Short menu comma separated: " + getShortMenuCommaSeparated());
}
private static long howManyDishes() {
return menu.stream().collect(counting());
}
private static Dish findMostCaloricDish() {
return menu.stream().collect(reducing((d1, d2) -> d1.getCalories() > d2.getCalories() ? d1 : d2)).get();
}
private static Dish findMostCaloricDishUsingComparator() {
Comparator<Dish> dishCaloriesComparator = Comparator.comparingInt(Dish::getCalories);
BinaryOperator<Dish> moreCaloricOf = BinaryOperator.maxBy(dishCaloriesComparator);
return menu.stream().collect(reducing(moreCaloricOf)).get();
}
private static int calculateTotalCalories() {
return menu.stream().collect(summingInt(Dish::getCalories));
}
private static Double calculateAverageCalories() {
return menu.stream().collect(averagingInt(Dish::getCalories));
}
private static IntSummaryStatistics calculateMenuStatistics() {
return menu.stream().collect(summarizingInt(Dish::getCalories));
}
private static String getShortMenu() {
return menu.stream().map(Dish::getName).collect(joining());
}
private static String getShortMenuCommaSeparated() {
return menu.stream().map(Dish::getName).collect(joining(", "));
}
}6、小结
通过上文，基本初步了解了lambda表达式是怎么规范定义、解析、执行。不仅Lambda用起来很方便，性能表现在多数情况也比匿名内部类好。我们在写lambda表达式时候，尽量写简介的代码，减少内部变量捕获（因为这样会创建额外的变量对象）。希望本文可以给大家一些参考。
532
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
