JAVA8之lambda表达式

一:lambda环绕执行模式

也许你们像我一样,目前对lambda表达式只是浅显的认为是,匿名内部类的简写形式,有点仅仅是看着好看点,可读性更强一点.

其实不然,lambda表达式是java8中函数参数化的一种重要体现.

让我们看下面一个小小的例子:

	public static String getChar(){
		List<String> list=new ArrayList<String>();
		list.add("a");
		list.add("b");
		list.add("c");
		list.add("d");
		return list.remove(0);
}

这是移除并获取数据集第一个资源的代码.如果我想获取前两个呢?或者第一个第三个呢?

我们需要不停地根据需求更改这段代码.怎么样才能一劳永逸呢?想下函数参数化

其实很简单,函数参数化的做法就是我们给一个接口定义一个方法簇(一个接口内方法名唯一的方法)这个方法簇的参数是你需要处理的内容,比如例子里的list数据集

public interface ListProcess {
	String  process(List<String> list);
}

这样我们只需要对原先的方法进行一次简单的修改即可,注意高亮部分

	public static String getChar(ListProcess l){
		List<String> list=new ArrayList<String>();
		list.add("a");
		list.add("b");
		list.add("c");
		list.add("d");
		return l.process(list)
}

接下来进行我们想要的操作即可

String char1 = getChar((List<String> list)->list.remove(0)+list.remove(0));

二.默认函数式接口
  .predicate参数<T>  返回值boolean

例子:

	public static void main(String[] args) {
		List<String> list = Arrays.asList("abc","bbc","cbd","a","ab");
		List filter = filter(list, (String str)->str.length()>2);
		System.out.println(filter);
	}
	//predicate
	public static List filter(List<String> list, Predicate<String> p){
		List<String> result=new ArrayList<String>();
		for (String l : list) {
			if(p.test(l)){
				result.add(l);
			}
		}
		return result;
	}

.consumer参数<T> 返回值void:

例子:

public static void main(String[] args) {
		List<String> list = Arrays.asList("abc","bbc","cbd","a","ab");
		print(list, (str)->System.out.println(str));
	}
	//consumer
	public static void print(List<String> list, Consumer c){
		for (String s : list) {
			c.accept(s);
		}
	}

.function参数<T> 返回值<R>

例子:

public static void main(String[] args) {
		List<String> list = Arrays.asList("abc","bbc","cbd","a","ab");
		List doIt = doIt(list, (String str)->str+"hehe");
		System.out.println(doIt);
	}
	//function
	public static List doIt(List<String> list, Function<String,String> f){
		List<String> result=new ArrayList<String>();
		for (String s : list) {
			result.add(f.apply(s));
		}
		return result;
	}

从lambda表达式你可以感觉到java8的设计者为了性能问题委实煞费苦心,大家都知道基本类型和它自己的包装类自己可以进行自动的封箱拆箱,但是这是需要消耗性能的

而设计者为我们提供了一系列,默认的函数式接口

函数式接口	函数描述符	原始类型特化
Predicate<T>	T->Boolean	IntPredicate,LongPredicate,DoublePredicate
Consumer<T>	T->void	IntConsumer,DoubleConsumer,LongConsumer
Function<T,R>	T->R	IntFunction<R>,IntToDoubleFunction,IntToLongFuntion LongFunction<R>,LongToIntFunction,LongToDoubleFuntion DoubleFunction<R>,DoubleToIntFunction,DoubleToLongFunction
Supplier<T>	()->T	BooleanFUpplier,IntSupplier,LongSupplier,DoubleSupplier
UnaryOperator<T>	T->T	IntUnaryOperator,DoubleUnaryOperator,LongUnaryOperator
BinaryOperator<T>	(T,T)->T	IntBinaryOperator,LongBinaryOperator,DoubleBinaryOperator
BiPredicate<L,R>	(L,R)->boolean
BiConsumer<T,U>	(T,U)->void	ObjIntConsumer<T>,ObjLongConsumer<T>,ObjDoubleConsumer<T>
BiFuntion<T,U,R>	(T,U)->R	ToIntBiFunction<T,U>,ToLongBiFunction<T,U>,ToDoubleBiFunction<T,U>