Java基础之Lambda与接口默认方法

Lambda表达式

Lambda表达式是Java SE 8中一个重要的新特性。本质上是一个“语法糖”，由编译器推断其含义，因此，可以使用更少的代码来实现同样的功能。

语法糖（Syntactic sugar），也译为糖衣语法，是由英国计算机科学家彼得·约翰·兰达（Peter J.Landin）发明的一个术语，指计算机语言中添加的某种语法，这种语法对语言的功能并没有影响，但更方便程序员的使用；只有CPU的微代码不是语法糖，其余代码包括机器语言都是语法糖。

Lambda语法

1、单语句语法：

(参数列表)->statement

举例说明：

（1）无参，返回100

        ()->100

（2）接收一个int型参数，并返回其5倍

       (int x)->x*5;或者：(x)->x*5;

（3）接收2个int型整数，并返回他们的和

      (int x,int  y)->x+y;或者：(x,y)->x+y;

（4）接收一个String型参数，并打印

      (String s)->System.out.println(s);或者：(s)->System.out.println(s);

2、遍历集合

集合对象.froEach(x->System.out.println(x));

或者：集合对象.forEach(System.out::println);

3、方法引用

实例对象::实力方法

类名称::静态方法

Stream API

Java8的Stream是对集合（Collection）对象功能的增强，可以对集合对象进行各种非常便利、高效的聚合操作。Stream API与Lambda表达式一起使用，可以提高编程效率。

转换Stream的常用方法

1、Stream中的map()使用一个给定的函数作用于原Stream中的每个元素，从而返回一个新的Stream。

举例：

list stream().map((x)->x + ".test").forEach(System.out::println);

2、Stream中的filter()对Stream中包含的元素使用给定的过滤函数进行过滤操作，新生成的Stream只包含符合条件的元素。

list.stream().filter(x->x.startsWith("张")).forEach(System.out::Println);

函数式接口Predicate

Predicate函数式接口的主要作用就是提供一个test方法，test方法接收一个参数，并返回一个布尔类型，Predicate在Stream API中进行一些判断的时候非常常用。

List<String> resultList = list.stream().filter(x->x.startWith("J")).collect(Collectors.toList())

Lambda单语句语法实例：

package statement;

public interface InterfaceA {
	public int methodA();
}

package statement;

public interface InterfaceB {
	public int methodB(int x,int y);
}

package statement;

public interface InterfaceC {
	public void metodC(String s);
}

package statement;

public class LambdaTest {

	public static void main(String[] args) {
		InterfaceA a = ()->250;
		System.out.println(a.methodA());
		
		InterfaceB b = (int x,int y)->x + y;
		System.out.println(b.methodB(55,66));
		
		InterfaceC c = (String s)->System.out.println("接收的信息内容是：" + s);
		c.metodC("Hello Java!");
	}

}

运行结果：

遍历集合实例：

package foreach;

import java.util.*;

public class ForeachDemo {

	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		Collections.addAll(list,"apple","banana","peach","orange");
		System.out.println("第一种Lambda遍历：");
		list.forEach(x->System.out.println(x));
		
		System.out.println("第二种Lambda遍历：");
		list.forEach(System.out::println);
	}

}

运行结果：

Stream中的map()实例：

package stream;

import java.util.*;

public class MapDemo {

	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		Collections.addAll(list,"red","yellow","blue","green","orange");
		list.stream().map((x)->x + ".jpg").forEachOrdered(System.out::println);

	}

}

运行结果：

Stream中的filter()实例：

package stream;

public class Student {
	private String name;
	private int age;
	private double score;

	public Student(String name, int age, double score) {
		super();
		this.name = name;
		this.age = age;
		this.score = score;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

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

	public double getScore() {
		return score;
	}

	public void setScore(double score) {
		this.score = score;
	}

	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + ", score=" + score + "]";
	}

}

package stream;

import java.util.*;

public class FilterDemo {

	public static void main(String[] args) {
		List<Student> list = new ArrayList<Student>();
		Collections.addAll(list,new Student("张三",20,66),new Student("李四",19,87),new Student("薛玉",22,78.5));
		list.stream().filter(x->{
				System.out.println("正在查看" + x.getName() + "是否符合要求...");
				return x.getScore() >= 77;
			}
		).forEach(System.out::println);;

	}

}

运行结果：

函数式接口Predicate实例：

package stream;

import java.util.function.Predicate;

public class PredicateDemo {

	public static void main(String[] args) {
		Predicate<String> pre = x->x.startsWith("o");
		System.out.println(pre.test("apple"));
		System.out.println(pre.test("orange"));

	}

}

运行结果：