lambda使用

lambda使用

循环调用方法,指定次数
public static void repeat(int n, IntConsumer action) {
    for (int i = 0; i < n; i++) {
        action.accept(i);
    }
}

执行两个消费动作
public static void acceptAndThen(Integer i, Consumer<Integer> consumer, Consumer<Integer> afterConsumer) {
    consumer.andThen(afterConsumer);
}

执行两个判断
= a.equals(x) || b.eqauls(x)
public static <T> Boolean test(T i) {
    return Predicate.isEqual(12).or(Predicate.isEqual(13)).test(i);
}

可以生成返回函数方法的小方法提高代码的阅读性
调整图片亮度
Image transform(Image in,UnaryOperator<Color> f){
	...
	f.apply(in.getColor());
}
// 固定调整
Image brightImage = transform(image,Color::brighter);	
// 如果想要根据像素或者按照需要调整亮度呢
1.重载
	transform(Image in,BiFunction<Color,T> f,T args)
2.生成一个返回值为UnaryOperator<Color>的方法
	UnaryOperator<Color> brighten(double factor){
		return c -> c.deriverColor(0,1,factor,1);
	}
	transform(image,brighten(1.2));
	Arrays.sort(values,ComparatorGenerator(自定义编写))

• 通用函数式接口

函数式接口	参数类型	返回类型	抽象方法名	描述	其他方法
Runanble	无	void	run	执行一个没有参数和返回值的操作
Supplier<T>	无	T	get	提供一个T类型的值
Consumer<T>	T	void	accept	处理一个T类型的值	chain
BiConsumer<T,U>	T,U	void	accept	处理T和U类型的值	chain
Function<T,R>	T	R	apply	一个参数为T的函数	compose(参数先执行),andThen(参数后执行),identity(返回本身)
BIFunction<T,U,R>	T,U	R	apply	一个参数类型为TheU的函数	andThen
UnaryOperator<T>	T	T	apply	对类型T的进行一元操作	compose,andThen,identity
BinaryOperator<T>	T,T	T	apply	对类型T进行二元操作	andThen
Predicate<T>	T	boolean	test	一个计算Boolean值的函数	And,Or,Negate,isEqual
Bipredicate<T,U>	T,U	boolean	test	一个含有两个参数,并计算Boolean的值	And,or,negate,isEqual

组合

1.场景:印刷图书时,先调亮图片,再转黑白 调用两次方法生成两个对象,浪费空间
UnaryOperator<T> compose(UnaryOperator<T> op1,UnaryOperator<T> op2){
	return t-> op2.apply(op1.apply);
}
transform(image,compose(Color::brighter,Color::grayscale));

延迟执行(stream内部实现延迟执行)

多方法调用,不能改变原有的Image类
LatentImage latent = transform(image,Color::brighter);
public class LatentImage {
		private Image in;
		private LIst<UnaryOperator<Color>> pendingOperations;
		...
		LatentImage transform(UnaryOperator<Color> f){
			pendingOperations.add(f);
			return this;
		}
		
		Image toImage(){
			..
			Color c = in.getColor();	
			for(UnaryOperator<color> f:pendingOperations){
				c = f.apply(c);
			}
			Image out = new Image();
			return  out.setColor(c);
		}
}
Image image = LatentImage.from(image)
	.transform(Color::brighter)
	.transform(Color::grayscale)
	.toImage();
最终调用image时延迟执行

并行操作

当不关心细节,得到操作结果,不关心顺序
多像素图片转换
Color[] [] parallelTransform(Color[][] in,UnaryOperator<Color> f){
	int n = Runtime.getRuntime().availableProcessors();
	Color[][] out= ...
	try{
		ExecutorService pool ...
		for(int i = 0 ;i<n;i++){
			int fromY = i*height/n;
			int toY = (i+10)*height/n
			pool.submit(()->{
				for(x)
				for(y	= fromY;y<toY;y++)
				out[x][y] =  f.apply(in[x][y])
			});
		}
		pool.shutdown;
		pool.awaitTermination(1,TImeUnit.Hours);
	}catch ...
	return out;
}