内容来自《 java8实战 》，本篇文章内容均为非盈利，旨为方便自己查询、总结备份、开源分享。如有侵权请告知，马上删除。
书籍购买地址：java8实战
那到底哪些因素会造成副作用呢?(副作用就是函数的效果已经超出了函数自身的范围)
什么是"如何做":就是你通过编程告诉计算机:第一步第二步第三步都要做什么,比如
List<String> list = new ArrayList<>();
List<String> collect = new ArrayList<>();
for (String s : list) { //告诉如何遍历list
if (!"str".equals(s)){ //告诉筛选条件
collect.add(s); //告诉如何收集到List
}
}而"要做什么"风格的编程通常被称为声明式编程,你给出希望完成的目标,让系统来决定如何实现这个目标,比如
List<String> list = new ArrayList<>();
List<String> collect = list.stream()
.filter(s -> !"str".equals(s))
.collect(Collectors.toList());
到这自己的函数的理解就是:函数是函数,java函数是java函数,由于单纯的函数完全可以像数据公式一样,传入相同的值返回相同结果,类似上面的黑盒图,而java函数如果需要用到数学函数的情况下,完全也可以写一个纯粹的java函数,它完全的无副作用,就好像用方法体的花括号隔绝了一切,出入形参,任何地方都不会跟程序有瓜葛,但是除了一些纯粹的java函数用来计算,其他的java函数还是需要跟程序的整体挂钩的,因为函数的执行不仅依赖于输入值,而且会受到全局变量,输入文件,类的成员变量等诸多因素的影响.
BiFunction<Integer,Integer,Integer> compare = Integer::compare; 高阶函数
public static <T, U extends Comparable<? super U>> Comparator<T> comparing(
Function<? super T, ? extends U> keyExtractor) //接收一个函数
{
Objects.requireNonNull(keyExtractor);
return (Comparator<T> & Serializable) //返回一个函数
(c1, c2) -> keyExtractor.apply(c1).compareTo(keyExtractor.apply(c2));
}Apple a1 = new Apple(12);
Apple a2 = new Apple(22);
Comparator<Apple> comparing = Comparator.comparing(Apple::getWeight);
int compare = comparing.compare(a1, a2);
System.out.println("compare = " + compare);(c1, c2) -> keyExtractor.apply(c1).compareTo(keyExtractor.apply(c2));,a1对c1,a2对c2然后分别对c1c2调用apply方法,这里的apply实现就是调用getWeight,需要注意的是 Comparator.comparing(Apple::getWeight);并没有去调用apple对象的此方法,因为这时候还没有实现具体的apply行为接受至少一个函数作为参数或返回的结果是一个函数任一一个条件,那么就可被称为高阶函数科里化
x*y+z,好了,我们按照这个写一个方法public static double getNum(int initNum , double adj , double deviator){
return initNum * adj + deviator;
}getNum(1000,0.3D,0.03D);
getNum(1210,0.2D,- 0.5D);
getNum(1000,0.5D,0.73D);
getNum(1050,0.5D,0.73D);public static DoubleUnaryOperator getNum( double adj , double deviator){
return (double x) -> x * adj + deviator;
}double applyAsDouble(double operand); DoubleUnaryOperator num1 = getNum(0.9D, 0.15D);
DoubleUnaryOperator num2 = getNum(0.12D, 0.75D);
//相同的调整参数调用
num1.applyAsDouble(1000);
num1.applyAsDouble(1111);
//对于不同的调整参数
num1.applyAsDouble(1211);科里化是一种将有两个参数的函数转换为使用一个参数的函数,并且这个函数的返回值也是一个函数,他会作为新函数的一个参数.后者的返回值和初始函数的返回值相同,即f(X,y) = (g(x))(y)
还是不太理解看例子:
Function<Integer, Function<Integer, Function<Integer, Integer>>> currying = x -> y -> z -> x*y*z;
Function<Integer, Integer> function = currying.apply(4).apply(5);
Integer apply = function.apply(1);//20
Integer apply1 = function.apply(2);//40如上是一个柯理化的实现:类似于一步一步的给值,然后每一步的值可以定制,又可以重用之前apply好的值,类似builder模式,build->build->build->over.
IntFunction<IntFunction<IntUnaryOperator>> function = x -> y -> z -> (x + y) * z;
IntFunction<IntUnaryOperator> apply = function.apply(2);i = apply2.applyAsInt(4);
System.out.println("i = " + i); //20
IntFunction的实现x -> y -> z -> (x + y) * z,第二次调用返回的是泛型中的IntFunction的实现 y -> z -> (x + y) * z,之后就剩下了IntUnaryOperator的实现z -> (x + y) * z 破坏式更新和函数式更新的比较
public class Train {
//0火车票价格
private int price;
//火车站点
private Train onward;
public Train(int price, Train onward) {
this.price = price;
this.onward = onward;
}
//setter getter
}public void test() {
Train train1 = new Train(12, null);
Train train2 = new Train(14, null);
Train link = link(train1, train2);
System.out.println(link); // Train{price=12, onward=Train{price=14, onward=null}}
System.out.println(train1); // Train{price=12, onward=Train{price=14, onward=null}}
System.out.println(train2); // Train{price=14, onward=null}
}
public static Train link(Train train1 , Train train2){
if (null == train1) return train2;
Train t = train1;
// 如果他又下一个,那么就遍历到没有下一个元素为止
while (t.getOnward() != null){
t = t.getOnward();
}
t.setOnward(train2);
return t;
}public void test() {
Train train1 = new Train(12, null);
Train train2 = new Train(14, null);
Train link = link(train1, train2);
System.out.println(link); // Train{price=12, onward=Train{price=14, onward=null}}
System.out.println(train1); // Train{price=14, onward=null}
System.out.println(train2); // Train{price=14, onward=null}
}
public static Train link(Train train1 , Train train2){
return train1 == null ? train2 : new Train(train1.getPrice(),link(train1.getOnward(),train2));
}
微信关注我们
转载内容版权归作者及来源网站所有！
低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。
为解决软件依赖安装时官方源访问速度慢的问题，腾讯云为一些软件搭建了缓存服务。您可以通过使用腾讯云软件源站来提升依赖包的安装速度。为了方便用户自由搭建服务架构，目前腾讯云软件源站支持公网访问和内网访问。
Spring框架（Spring Framework）是由Rod Johnson于2002年提出的开源Java企业级应用框架，旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念，提供核心容器、应用上下文、数据访问集成等模块，支持整合Hibernate、Struts等第三方框架，其适用范围不仅限于服务器端开发，绝大多数Java应用均可从中受益。
Rocky Linux（中文名：洛基）是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版，作为CentOS稳定版停止维护后与RHEL（Red Hat Enterprise Linux）完全兼容的开源替代方案，由社区拥有并管理，支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性，采用模块化包装和SELinux安全架构，默认包含GNOME桌面环境及XFS文件系统，支持十年生命周期更新。
Sublime Text具有漂亮的用户界面和强大的功能，例如代码缩略图，Python的插件，代码段等。还可自定义键绑定，菜单和工具栏。Sublime Text 的主要功能包括：拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。Sublime Text 是一个跨平台的编辑器，同时支持Windows、Linux、Mac OS X等操作系统。
扫码在手机上查看文章
扫描二维码，手机阅读更方便
有任何问题或合作意向欢迎联系我们
Email: 99873273@qq.com
QQ: 99873273