java【function】

函数式编程/lambda 表达式

关于为什么需要学习函数式编程,什么是函数式编程,之前在学习 javase 的时候,学到关于 lambda 表达式对一些知识,但是时间消磨了我,最近在做项目分析别人代码的时候,看到一大堆的 function 的方法使用,使得我引起了重视。

函数式编程:面向结果,对过程不在乎,例如实现的细节之类的。

一般的我们自己代码(命令式编程):面向过程编程。

代码演示

@Test
public void whyisfunction() {
	/**
     * 命令式编程
     */
	int[] nums = {12,10,13,14,78};
	//过程
	Integer max =Integer.MIN_VALUE;

	for (int i :nums) {

		if(i> max) {
			max = i;
		}
	}
	System.out.println(String.format("【命令式】%s", max));

	/**
	 * 函数式编程
	 */

	int asInt = IntStream.of(nums).max().getAsInt();

	System.out.println(String.format("【函数式】%s", asInt));
}

优势在于函数式编程可以快速是一个多线程,并行等,效率更高

我们以创建一个线程为实例的方式,进行演示

@Test
    public void runableTest() {
	/**
	 * 命令式写法
	 */
	new Thread(new Runnable() {
	
		@Override
		public void run() {
			System.out.println("【命令式】启动一个线程实例");
		
		}
	}).start();;

	/**
	 * 配置lambda表示写法
	 */

	new Thread(()->System.out.println("【函数式】启动一个线程实例")).start();
}

可能现在还不能很好的看出来,我们换一种方式写出来

@Test
public void runableTest2() {
	/**
	 * 命令式写法
	 */
	Runnable runnable = new Runnable() {
	
		@Override
		public void run() {
			System.out.println("【命令式】启动一个线程实例");
		
		}
	};

	new Thread(runnable).start();

	/**
	 * 配置lambda表示写法
	 */
	Runnable runnable2 = ()->System.out.println("【函数式】启动一个线程实例");
	Runnable runnable3 = ()->System.out.println("【函数式】启动一个线程实例");
  
    System.out.println(runnable2 == runnable3); //输出为false
  
	new Thread(runnable2).start();
}

从上面实例就可以看出来,对于 lambda 表示而言,他并不关注你实现的是哪个方法,它实现的就是一个接口里面的一个不带参数的方法,返回的就是指定接口实例。说到这里,小伙伴应该会想到为什么之前在 Thread 的时候,它可以使用 lambda,因为 Thread 这个接口符合 function 函数规则【定义为接口,并且只有一个抽象方法】,所以当我们使用()->System.out.println("【函数式】启动一个线程实例"),就能够找到返回的实例找到实现方法,如果有多个话,就可能出现不知道找谁了。

lambda 的案例使用

interface IMoneyout{
  String format2(int i);
}
class IMyMoney {
	private  int money =99999;

	public IMyMoney(int money) {
		this.money = money;
	}

	public void  getresult(IMoneyout iMoneyout){
	
		System.out.println(iMoneyout.format2(money));
	}

}

public class function02 {
    @Test
    public void test01() {

        IMyMoney im=new IMyMoney(99999);
        ArrayList<Integer> arrayList = new ArrayList<Integer>();

        im.getresult(hax->{
            arrayList.add(hax);
            return arrayList.toString();
        });

        im.getresult(hax->new DecimalFormat("#,###").format(hax));

    }
}

输出接口为

[99999],

99,999

使用 function 函数接口操作,Function<Integer, String>

class IMyMoney {

	private  int money =99999;

	public IMyMoney(int money) {
		this.money = money;
	}

	public void  getresult(Function<Integer, String> iMoneyout){
	
		System.out.println(iMoneyout.apply(money));
	}

}

public class function02 {

	@Test
	public void test01() {
	
		IMyMoney im=new IMyMoney(99999);
		ArrayList<String> arrayList = new ArrayList<String>();
	
		/**
		 * 使用函数接口,可以进行链式操作
		 */
	
		Function<Integer, String> iMoneyout = hax->new DecimalFormat("#,###").format(hax);
	
		im.getresult(iMoneyout.andThen(s->{
			arrayList.add("人民币"+s);
			return arrayList.toString();
		}));
	}

}

基本的函数接口,使用代码的形式为大家解释,代码中都存在注解。

public class function03 {

	class person{
	
		private String name;
		private char sex;
		private Integer age;
		public String getName() {
			return name;
		}
		public void setName(String name) {
			this.name = name;
		}
		public char getSex() {
			return sex;
		}
		public void setSex(char sex) {
			this.sex = sex;
		}
		public Integer getAge() {
			return age;
		}
		public void setAge(Integer age) {
			this.age = age;
		}
		public person(String name, char sex, Integer age) {
			super();
			this.name = name;
			this.sex = sex;
			this.age = age;
		}
		public person(String name) {
			super();
			this.name = name;
		}
		public person() {
			super();
		}
		@Override
		public String toString() {
			return "person [name=" + name + ", sex=" + sex + ", age=" + age + "]";
		}
	}

	@Test
	public void test01() {
	
		//断言函数
		Predicate<Integer> predicate = i->i>=10;
		System.out.println(predicate.test(10));
	
		//消费者->消费一个数据
		Consumer<String> consumer =  i ->System.out.println(i);
		consumer.accept("消费者函数");
	
		//function函数->输入输出
		Function<Date, String> function = hax-> new SimpleDateFormat("yyyy-MM-ss:HH:mm:ss").format(hax);
		System.out.println(function.apply(new Date()));
	
		//一元函数->输入和输出是一样的类型
		UnaryOperator<function03.person> uOperator = hax -> {
		
			if(hax!=null && hax.getAge()<18 && "女".equals(hax.getSex()) ) {
			
				hax.setAge(18);
			}
			return hax;
		
		};
	
		System.out.println(uOperator.apply(new function03.person("ff",'女',19)).toString());
	
		/**
		 * 二个输入,一个输出函数
		 */
		function03.person person = new function03.person();
	
		BiFunction<function03.person, String, function03.person> biFunction = (hax,haxstring)-> new function03.person(haxstring);
	
		System.out.println(biFunction.apply(person, "yy"));;
	
		/**
		 * 提供者
		 */
		Supplier<String> supplier = () ->  new function03.person("supplier").toString();
	
		System.out.println(supplier.get());
	
		/**
		 * 二元函数->参数2个,传入的参数相同,返回的参数也相同 
		 */
	
		BinaryOperator<String> binaryOperator = (hax1,hax2)->new StringBuilder(hax1).append(hax2).toString();
	
		System.out.println(binaryOperator.apply("二元", "函数"));
	
		/**
		 * 对于基本类型来说,function提供了一些基本的类型实现,不需要在写泛型
		 */
		//
		IntPredicate predicate2 = i ->i >=10;
		System.out.println(predicate2.test(10));
	
	//string类型的没有
		IntConsumer consumer2 = i ->System.out.println(i);
		consumer2.accept(10);
	
	} 

}

返回结果为

true
消费者函数
2021-04-53:10:13:53
person [name=ff, sex=女, age=19]
person [name=yy, sex= , age=null]
person [name=supplier, sex=, age=null]
二元函数
true
10

总而言之使用函数式的编程方式,发现我们不在去关注你需要实现的是什么方法,关注点只在于,你需要什么类型参数,返回值就可以,我们在 lambda 表达式中写入自己想实现的操作,可以用法等一系列的操作进行实现,然后将结果拿到进行返回操作,方便弄好实现,并且我们可以通过自己自定义的函数接口,对制定的一些方法进行标准化。

  • Java

    Java 是一种可以撰写跨平台应用软件的面向对象的程序设计语言,是由 Sun Microsystems 公司于 1995 年 5 月推出的。Java 技术具有卓越的通用性、高效性、平台移植性和安全性。

    2920 引用 • 8120 回帖 • 671 关注
  • function
    3 引用 • 16 回帖

广告 我要投放

欢迎来到这里!

我们正在构建一个小众社区,大家在这里相互信任,以平等 • 自由 • 奔放的价值观进行分享交流。最终,希望大家能够找到与自己志同道合的伙伴,共同成长。

注册 关于
请输入回帖内容 ...