【Java SE进阶】Day12 函数式接口、函数式编程(Lambda表达式)
一、函数式接口介绍
1、概念
- 仅有一个抽象方法的接口
- 适用于函数式编程(Lambda使用的接口)
- 语法糖:方便但原理不变,如for-each是Iterator的语法糖
- Lambda≈匿名内部类的语法糖
2、格式
- @FunctionalInterface注解
- 可以检测接口是否是一个函数式接口,不是则编译失败
3、使用
- 常规写法:
- 编写接口实现类
- 定义方法,参数传递接口,方法内调用接口的方法
- main方法调用
package com.liujinhui.Day1207FunInterface;
/*
函数式接口的使用(作为函数参数或返回值类型)
* */
public class Demo {
//定义一个方法,参数使用函数式接口MyFunInterface
public static void show(MyFunInterface myInter){
myInter.method();
}
public static void main(String[] args) {
//调用函数参数中的接口时,传递接口的实现类对象
//1.调用show方法,方法的参数 是一个接口,所以可以传递接口的实现类对象
show(new MyFunInterfaceImpl());
//2.调用show方法,方法的参数是一个接口,可以传递接口的匿名内部类
show(new MyFunInterface() {
@Override
public void method() {
System.out.println("使用匿名内部类重写接口中的抽象方法");
}
});
//3.调用show方法,方法的参数是一个函数式接口,所以可以使用Lambda表达式
show(()->{
System.out.println("使用Lambda表达式重写接口中的抽象方法");
});
//4.简化Lambda表达式
show(()->System.out.println("使用Lambda表达式的简化重写接口中的抽象方法"));
}
}
- Lambda表达式:方法名(()->{});
- Lambda的简化写法 :方法名(()->);
4、区别
- 匿名内部类会被保存为Demo$1.class字节码文件
- Lambda不会保存为class
- 匿名内部类:定义new 接口,内部重写接口的抽象方法
二、函数式编程
1、性能浪费的日志案例
- 有些场景的代码执行后,结果不一定会被使用,从而造成性能浪费
- Lambda延迟执行,可以提升性能
- 例子:根据日志等级进行输出
package com.liujinhui.Day1207FunInterface.Lambda;
/*
日志案例 以上代码存在性能浪费的问题
调用showLog方法时,传递的第二个参数是一个拼接后的字符串
先把字符串拼接好,再调用showLog方法
showLog方法如果传递的日志等级不是1级,就不会输出拼接后的字符串
所以感觉字符串就白拼接了,所以存在着浪费
* */
public class Demo01Logger {
//定义一个根据日志级别,显示日志信息的方法
public static void showLog(int level, String message){
//对日志的等级进行判断,如果是1,输出日志的信息
if(level==1){
System.out.println(message);
}
}
public static void main(String[] args) {
//定义三个日志信息
String msg1="hello";
String msg2="world";
String msg3="java"; //调用showLog方法,传递日志级别和日志信息
showLog(1,msg1+msg2+msg3);
//为2时不输出
showLog(2,msg1+msg2+msg3);
}
}
2、使用Lambda进行日志优化
package com.liujinhui.Day1207FunInterface.Lambda;
/*
使用Lambda优化日志案例
Lambda的特点:延迟加载
Lambda的使用前提,必须存在函数式接口
* */
public class Demo02Lambda {
//定义 一个显示日志的方法没方法的参数传递日志的等级和MessageBuilder接口
public static void showLog(int level,MessageBuilder mb){
//对日志的等级进行判断,如果是1级,调用MessageBuilder接口中的builderMessage方法
if (level==1){
//优先级为1,就进行输出
System.out.println(mb.builderMessage());
}
}
public static void main(String[] args) {
//定义三个日志信息
String msg1="hello";
String msg2="world";
String msg3="java";
//调用showLog方法,参数MessageBuilder是一个函数式接口,故可以使用Lambda表达式
/* showLog(2,()->{
//返回一个拼接好的字符串
return msg1+msg2+msg3;
});*/
//结果一样但性能不同
/*
Lambda表达式只有满足条件时才会执行,不满足条件就不执行
使用Lambda表达式作为参数传递,仅仅是把参数传递到showLog方法中
只有满足条件-日志的等级是1级时
才会调用接口MessageBuilder中的方法builderMessage
才会进行字符串的拼接
如果条件不满足,日志的等级不是1级
那么接口MessageBuilder中的方法builderMessage不会执行
所以拼接字符串的代码也不会执行
所以不会存在性能的浪费
* */
showLog(1,()->{
System.out.println("不满足条件不执行");
//返回一个拼接好的字符串
return msg1+msg2+msg3;
});
}
}
- 不满足条件不执行接口的方法
3、函数式接口作为参数
package com.liujinhui.Day1207FunInterface.ThreadTest;
/*
java.lang.Runnable 接口就是一个函数式接口,
假设有一个 startThread 方法使用该接口作为参数,
可以使用Lambda进行传参。这种情况其实和 Thread 类的构造方法参数为 Runnable 没有本质区别。
* */
public class Demo01Runnable {
//定义一个方法stratThread,方法的参数使用函数式接口Runnable
public static void startThread(Runnable run){
//开启多线程
new Thread(run).start();
}
public static void main(String[] args) {
//调用startThread方法,方法的参数是一个接口,可以传递接口的匿名内部类
startThread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"-->"+"线程启动了");
}
});
//使用Lambda表达式优化函数式接口,参数传递Lambda表达式
startThread(()->{
System.out.println(Thread.currentThread().getName()+"-->"+"线程启动了");
});
//lambda的优化
startThread(()->System.out.println(Thread.currentThread().getName()+"-->"+"线程启动了"));
}
}
4、函数式接口作为返回值
package com.liujinhui.Day1207FunInterface.ThreadTest;
import java.util.Arrays;
import java.util.Comparator;
/*
,如果一个方法的返回值类型是一个函数式接口,
那么就可以直接返回一个Lambda表达式。
当需要通过一 个方法来获取一个 java.util.Comparator 接口类型的对象作为排序器时,就可以调该方法获取。
* */
public class Demo02Comparator {
//定义一个方法,方法的返回值类型使用函数式接口Comparator
public static Comparator<String> getComparator(){
//方法的返回值类型是一个接口,那么可以返回这个接口的匿名内部类
/*
return new Comparator<String>() {
@Override
public int compare(String o1,String o2){
//按照字符串的降序排序
return o2.length()-o1.length();
}
};
*/
//方法的返回值是一个函数式接口,可以返回一个Lambda表达式
/**/ /*return (String o1,String o2)->{
//按照字符串的降序排序
return o2.length()-o1.length();
};*/
//继续优化Lambda表达式
return (o1,o2)->o2.length()-o1.length();
}
public static void main(String[] args) {
//主方法调用:创建一个字符串数组
String[] arr={"aaa","b","cccc","dddddddddddddd"};
//输出排序前的数组[aaa, b, cccc, dddddddddddddd]
System.out.println(Arrays.toString(arr));
//调用Arrays中的sort方法,对字符串数组进行排序
Arrays.sort(arr,getComparator());
//输出排序后的数组[dddddddddddddd, cccc, aaa, b]
System.out.println(Arrays.toString(arr));
}
}
三、常用的函数式接口
1、生产型接口(Supplier接口)
- 只包含一个无参方法get
- java.util.function.Supplier<T>
package com.liujinhui.Day1207FunInterface.CommonPackage; import java.util.function.Supplier; /*
常用的函数式接口
java.util.function.Supplier<T>接口仅包含一个无参的方法: T get() 。 Supplier<T>接口被称为生产型接口,指定接口的泛型是什么类型,那么接口中的get方法就会产生什么类型的数据
* */
public class Demo01Supplier {
//定义一个方法,方法的参数传递Supplier<T>接口,泛型执行String,get就会返回一个String
public static String getString(Supplier<String> sup){
return sup.get();
}
//调用
public static void main(String[] args) {
//调用getString方法,方法的参数Supplier是一个函数式接口,所以可以传递Lambda表达式
String s=getString(()->{
//生产一个字符串并返回
return "你好";
});
System.out.println(s);
//Lambda表达式的优化
String s2=getString(()->"helloworld");
System.out.println(s2);
}
}
- 练习:求数组元素最大值
package com.liujinhui.Day1207FunInterface.CommonPackage; import java.util.function.Supplier; /* 练习:求数组元素的最大值
使用 Supplier 接口作为方法参数类型,通过Lambda表达式求出int数组中的最大值。
提示:接口的泛型请使用 java.lang.Integer 类。 * */
public class Demo02SupplierTest {
//定义一个方法,用于获取int类型数据元素的最大值
public static int getMax(Supplier<Integer> sup){
return sup.get();
} public static void main(String[] args) {
//定义一个int型数组
int[] arr={100,20,50,0,79,399,-30};
//调用getMax方法,方法的参数是Supplier接口,可以传递Lambda表达式
int maxValue = getMax(() -> {
//获取数组元素的最大值,并返回
//定义一个变量,把数组中的第一个元素赋值给该变量,记录数组中元素的最大值
int max = arr[0];
//遍历数组,获取数组中的其他元素
for (int i : arr) {
//使用其他的元素和最大值比较
if (i > max) {
//如果有比max大的,则替换max作为最大值
max = i;
}
}
return max;
});
System.out.println("数组中元素的最大值是"+maxValue);
}
}
2、消费者接口(Consumer)
- 只包含一个抽象方法accept
- java.util.function.Consumer<T>
package com.liujinhui.Day1207FunInterface.CommonPackage;
import java.util.function.Consumer;
/*
java.util.function.Consumer<T> 接口则正好与Supplier接口相反,它不是生产一个数据,而是消费一个数据, 其数据类型由泛型决定。
* */
public class Demo03Consumer {
/*
定义一个方法,方法参数传递一个字符串的姓名
方法的参数传递Consumer接口,泛型使用String
可以使用Consumer接口消费字符串的姓名 * */
public static void method(String name, Consumer<String> con){
con.accept(name);
}
public static void main(String[] args) {
//调用method方法,传递字符串姓名,方法的另一个参数是Consumer接口,是一个函数式接口,
//所以可以传递Lambda表达式
method("dog",(String name)->{
//对传递的字符串进行消费
//消费方式:直接输出字符串
// System.out.println(name);
//消费方式:把字符串进行反转输出
//StringBuilder里面的Reverse
String newName=new StringBuilder(name).reverse().toString();//链式编程
System.out.println(newName);
});
}
}
- Consumer接口的默认方法andThen
package com.liujinhui.Day1207FunInterface.CommonPackage; import java.util.function.Consumer; /*
Consumer接口的默认方法andThen
作用:需要两个Consumer接口,可以把两个consumer接口组合到一起,再对数据进行消费 例如:
Consumer<String> con1;
Consumer<String> con2;
String s="hello";
con1.accept(s);
con2.accept(s); 连接两个Consumer接口进行优化
con1.andThen(con2).accept(s);//谁写前面谁先消费
* */
public class Demo04Comsummer {
//定义一个方法,方法的参数传递一个字符串和两个Consumer接口,Consumer接口的泛型使用字符串
public static void method(String s1, Consumer<String> con1,Consumer<String> con2){
/*con1.accept(s1);
con2.accept(s1);*/
//使用andThen方法,把两个Consumer接口连接到一起,再消费数据
con1.andThen(con2).accept(s1);//按先后顺序消费
} public static void main(String[] args) {
//调用method方法,传递一个字符串和两个Lambda表达式
method("hello",(t)->{
//消费方式:把字符串转换为大写输出
System.out.println(t.toUpperCase());
},(t)->{
System.out.println(t.toLowerCase());
});
}
}
- 消费数据的时候,按先后顺序消费
- 练习:字符串拼接输出/格式化打印信息
- 按照格式“ 姓名:XX。性别:XX。 ”的格式将信息打印出来。
package com.liujinhui.Day1207FunInterface.CommonPackage;
import java.util.function.Consumer;
/*
按照格式“ 姓名:XX。性别:XX。 ”的格式将信息打印出来。
要求将打印姓 名的动作作为第一个 Consumer 接口的Lambda实例,
将打印性别的动作作为第二个 Consumer 接口的Lambda实 例,将两个 Consumer 接口按照顺序“拼接”到一起。
* */
public class Demo05ConsumerTest {
//定义一个方法,参数传递数组和两个Consumer接口,使用String泛型
public static void printInfo(String[] arr, Consumer<String> con1,Consumer<String> con2){
//遍历字符串数组
for (String message : arr) {
//使用andThen方法连接两个Consumer接口,消费字符串
con1.andThen(con2).accept(message);
}
}
public static void main(String[] args) {
//定义一个字符串类型的数组
String[] arr={"迪丽热巴,女","古力娜扎,女","马尔扎哈,男"};
//调用printInfo方法,传递一个字符串数组和两个lambda表达式
printInfo(arr,(message)->{
//消费方式:对message进行切割,获取姓名,再按照指定格式输出
String name = message.split(",")[0];
System.out.print("姓名:"+name);
},(message)->{
//消费方式:对message进行切割,获取年龄,再按照指定格式输出
String age = message.split(",")[1];
System.out.println("。年龄:"+age+"。");
});
}
}
3、Predicate接口
- java.util.function.Predicate<T>
- 有唯一 抽象方法test(T),对 某种类型的数据进行判断
package com.liujinhui.Day1207FunInterface.CommonPackage; import java.util.function.Predicate; /*
java.util.function.Predicate<T> 接口。
作用:对某种数据类型的数据进行判断,结果返回boolean值 Predicate接口中包含一个抽象方法
boolean test(T t) 。用于条件判断的场景:
符合条件,返回true
不符合条件,返回false
* */
public class Demo06Predicate {
/*
定义一个方法
参数传递一个STring 类型的字符串
传递一个Predicate接口,泛型使用String
使用Predicate中的方法对字符串进行判断,并把判断的结果进行返回 * */
public static boolean checkString(String s, Predicate<String> pre){
return pre.test(s);
}
public static void main(String[] args) {
//定义一个字符串
String s="abcdef";
//使用checkString方法对子字符串进行校验,参数传递字符串和lambda表达式
/*boolean b = checkString(s, (String str) -> {
//对参数传递的字符串进行判断,判断字符串的长度是否大于5,并把判断的结果返回
return str.length() > 5;
});*/
//lambda表达式的优化
boolean b = checkString(s, (str) -> str.length() > 5);
System.out.println(b);
}
}
- 默认方法
- and
- or
- negate
- 同时满足长度大于5且包含a的字符串
package com.liujinhui.Day1207FunInterface.CommonPackage;
import java.util.function.Predicate;
/*
逻辑表达式:可以连接多个判断的条件
&&:有false则false
||:有true则true
!:非真则假 需求:判断一个字符串,有两个判断条件
1.判断字符串的长度是否大于5
2.判断字符串中是否包含a
两个条件必须同时满足,就可以使用&&运算符连接两个条件 Predicate接口中有一个方法and,表示并且关系 ,也可以用于连接两个判断条件
default Predicate<T> and(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) ‐> test(t) && other.test(t);
}
方法内的两个判断条件也是使用与运算符连接起来的
* */
public class Demo07PredicateAnd {
/*
定义一个方法,方法的参数传递一个字符串
传递 两个Predicate接口
一个用于判断字符串的长度是否大于5
一个用于判断字符串中是否包含a
两个条件必须同时满足
* */
public static boolean checkString(String s, Predicate<String> pre1,Predicate<String> pre2){
// return pre1.test(s)&&pre2.test(s);
//改造:使用and来实现
return pre1.and(pre2).test(s);
}
public static void main(String[] args) {
//定义一个字符串
String s="abcdef";
//调用checkString方法,参数传递字符串和两个Lambda表达式
boolean b = checkString(s, (String str) -> {
return str.length()>5;
}, (String str) -> {
//判断字符串是否包含a
return str.contains("a");
});
System.out.println(b);
}
}
- 满足其中之一的
package com.liujinhui.Day1207FunInterface.CommonPackage;
import java.util.function.Predicate; /*
逻辑表达式:可以连接多个判断的条件
&&:有false则false
||:有true则true
!:非真则假 需求:判断一个字符串,有两个判断条件
1.判断字符串的长度是否大于5
2.判断字符串中是否包含a
满足一个条件即可,就可以使用||运算符连接两个条件 Predicate接口中有一个方法and,表示并且关系 ,也可以用于连接两个判断条件
default Predicate<T> or(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) ‐> test(t) || other.test(t);
}
方法内的两个判断条件也是使用||运算符连接起来的
* */
public class Demo07PredicateOrNegate {
/*
定义一个方法,方法的参数传递一个字符串
传递 两个Predicate接口
一个用于判断字符串的长度是否大于5
一个用于判断字符串中是否包含a
满足一个条件即可
* */
public static boolean checkString(String s, Predicate<String> pre1,Predicate<String> pre2){
// return pre1.test(s)||pre2.test(s);
// 改造:使用or来实现
return pre1.or(pre2).test(s);//等价于return pre1.test(s)||pre2.test(s);
}
public static void main(String[] args) {
//定义一个字符串
String s="abc";
//调用checkString方法,参数传递字符串和两个Lambda表达式
boolean b = checkString(s, (String str) -> {
return str.length()>5;
}, (String str) -> {
//判断字符串是否包含a
return str.contains("a");
});
System.out.println(b);
}
}
- 条件取反
package com.liujinhui.Day1207FunInterface.CommonPackage;
import java.util.function.Predicate;
/*
需求:判断字符串的长度是否大于5
如果字符串长度大于5,则返回false
如果长度不大于5,则返回true
所以,可以使用取反符号!进行取反 Predicate接口中有一个方法negate,也表示取反的意思
default Predicate<T> negate() {
return (t) ‐> !test(t);
}
* */
public class Demo08Negate {
/*
定义一个方法,方法的参数传递一个字符串
传递一个Predicate接口
一个用于判断字符串的长度是否大于5
* */
public static boolean checkString(String s, Predicate<String> pre){
//return !pre.test(s);
//改造:使用negate来实现
return pre.negate().test(s);//!!!!!!!!!!!
}
public static void main(String[] args) {
String s="abcabcabc";
//调用checkString方法,参数传递字符串和lambda表达式
boolean b = checkString(s, (String str) -> {
//判断字符串的长度是否大于5并返回结果
return str.length()>5;
});
System.out.println(b);
}
}
- 练习:集合信息筛选,将满足要求的字符串存入
- 女生、姓名为4个字
package com.liujinhui.Day1207FunInterface.CommonPackage; import java.util.ArrayList;
import java.util.function.Predicate; /*
数组当中有多条“姓名+性别”的信息如下,请通过 Predicate 接口的拼装
将符合要求的字符串筛选到集合 ArrayList 中,需要同时满足两个条件
1. 必须为女生; 2. 姓名为4个字。
分析:
1.有两个判断条件,故需要两个Predicate接口,对条件进行判断
2.必须同时满足,所以可以使用and方法连接两个判断条件 * */
public class Demo09TestInfo {
/*
定义一个方法
方法的参数传递一个包含人员信息的数组
传递两个Predicate接口,用于对数组中的信息进行过滤
把满足条件的信息存到ArrayLIst集合中并返回
* */
public static ArrayList<String> filter(String[] arr, Predicate<String> pre1,Predicate<String> pre2){
//定义一个ArrayList集合,存储过滤后的信息
ArrayList<String> list=new ArrayList<String>();
//遍历数组,获取数组中的每一条信息
for (String s : arr) {
//使用Predicate接口中的方法test对获取到的字符串进行判断
boolean b = pre1.and(pre2).test(s);
//对得到的布尔值进行遍历
if (b){
//条件成立,把信息存储到ArrayList集合中
list.add(s);
}
}
return list;
}
public static void main(String[] args) {
//定义一个能存字符串的数组
String[] array = { "迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男", "赵丽颖,女" };
//调用filter方法传递字符串数组和两个lambda表达式
ArrayList<String> list = filter(array, (String s) -> {
//获取字符串中的性别,判断是否为女
return s.split(",")[1].equals("女");
}, (String s) -> {
//获取字符串中的姓名,判断长度是否为4个字符
return s.split(",")[0].length() == 4;
});
//遍历集合
for (String s : list) {
System.out.println(s);
}
}
}
4、Function接口
- java.util.function.Function<T,R>
- 根据一个类型得到另一个类型的数据,可以实现类型的转换
package com.liujinhui.Day1207FunInterface.CommonPackage; import java.util.function.Function; public class Demo10Function {
/*
定义一个方法
方法的参数传递一个字符串类型的整数
方法的参数传递一个Function接口,泛型使用<String,Integer>
使用Function接口中的方法apply,将字符串类型的整数,转换为Integer类型的整数
* */
public static void change(String s, Function<String,Integer> fun){
// Integer in=fun.apply(s);
int in=fun.apply(s);//自动拆箱(Integer转换为int类型)
System.out.println(in);
}
public static void main(String[] args) {
//定义一个字符串类型的整数
String s="1234";
//调用change方法,传递字符串类型的整数和lambda表达式
/* change(s,(String str)->{
//把字符串类型转换为integer整数
return Integer.parseInt(str);
});*/
//优化
change(s,(String str)->Integer.parseInt(str));
}
}
- 默认方法andThen
package com.liujinhui.Day1207FunInterface.CommonPackage; import java.util.function.Function; /*
Function接口中的andthen方法,用来进行组合操作
需求:
把String类型的“123”转换为Integer,把转换后的结果+10
再把增加之后的integer类型数据,转换为string类型
分析:
转换了两次
第一次把String类型转换为Integer类型
可以用Function<String,Integer> fun1
int i=fun.apply("123")+10;
第二次把integer类型转换为了string类型
可以用Function接口<Integer,String> fun2
String s=fun2.aaply(i);
可以使用andThen方法,把两次转换组合在一起
String s=fun1.andThen(fun2).apply("123");
fun1先调用apply方法,把字符串转换为Integer方法
fun2再调用apply方法,把Integer转换为字符串类型
* */
public class Demo11FunctionAndThen {
/*
定义一个方法
参数传递一个字符串类型的整数
参数再传递两个Function接口
一个泛型使用Function<String,Integer> fun1
一个泛型使用Function接口<Integer,String> fun2
* */
public static void change(String s, Function<String,Integer> fun1,Function<Integer,String>fun2){
String ss = fun1.andThen(fun2).apply(s);
System.out.println(ss);
}
public static void main(String[] args) {
//定义一个字符串类型的整数
String s="123";
//调用change方法,传递字符串和两个lambda表达式
/* change(s,(String str)->{
//把字符串转换为整数
return Integer.parseInt(str)+10;
},(Integer i)->{
//把整数转换为字符串
return i+"";
});*/
//lambda的优化
//有参数时不能省略参数
change(s,str->Integer.parseInt(s)+10,i->i+"");
}
}
- 练习:将数字累加100
package com.liujinhui.Day1207FunInterface.CommonPackage; import java.util.function.Function; /*
题目:使用 Function 进行函数模型的拼接,按照顺序需要执行的多个函数操作为: String str = "赵丽颖,20"; 1. 将字符串截取数字年龄部分,得到字符串;
String str = "赵丽颖,20"; 得到20
2. 将上一步的字符串转换成为int类型的数字;
Function<String ,Integer> "20"->20
3. 将上一步的int数字累加100,得到结果int数字。
Function<Integer,Integer> 20->120
* */
public class Demo12FunctionConcate {
/*
定义一个方法
参数传递包括姓名和年龄的字符串
参数再传递三个Function接口用于类型转换
* */
public static int change(String s, Function<String,String> fun1,
Function<String,Integer> fun2,Function<Integer,Integer> fun3){
//使用andThen方法将三步操作组合到一起
return fun1.andThen(fun2).andThen(fun3).apply(s);
}
public static void main(String[] args) {
//定义一个字符串
String str = "赵丽颖,20";
//调用change方法,参数传递字符串和3个lambda表达式调用change
int num=change(str,(String s)->{
// "赵丽颖,20"得到"20"
return s.split(",")[1];
},(String s)->{
return Integer.parseInt(s);
},(Integer i)->{
return i+100;
});
System.out.println(num);
}
}
【Java SE进阶】Day12 函数式接口、函数式编程(Lambda表达式)的更多相关文章
- [二] java8 函数式接口详解 函数接口详解 lambda表达式 匿名函数 方法引用使用含义 函数式接口实例 如何定义函数式接口
函数式接口详细定义 package java.lang; import java.lang.annotation.*; /** * An informative annotation type use ...
- 函数式编程/lambda表达式入门
函数式编程/lambda表达式入门 本篇主要讲解 lambda表达式的入门,涉及为什么使用函数式编程,以及jdk8提供的函数式接口 和 接口的默认方法 等等 1.什么是命令式编程 命令式编程就是我们去 ...
- Python爬虫与数据分析之进阶教程:文件操作、lambda表达式、递归、yield生成器
专栏目录: Python爬虫与数据分析之python教学视频.python源码分享,python Python爬虫与数据分析之基础教程:Python的语法.字典.元组.列表 Python爬虫与数据分析 ...
- Java1.8新特性——接口改动和Lambda表达式
Java1.8新特性——接口改动和Lambda表达式 摘要:本文主要学习了Java1.8的新特性中有关接口和Lambda表达式的部分. 部分内容来自以下博客: https://www.cnblogs. ...
- Java 8新特性(一):Lambda表达式
2014年3月发布的Java 8,有可能是Java版本更新中变化最大的一次.新的Java 8为开发者带来了许多重量级的新特性,包括Lambda表达式,流式数据处理,新的Optional类,新的日期和时 ...
- 6.1 接口 - 6.3 lambda表达式
6.1 接口 接口概念 接口是对类的一组需求描述,这些类要遵从接口描述的统一格式进行定义.设计目的是解决多继承的问题 接口中所有方法时 public 不用现实声明 java.lang.Comparab ...
- 函数式编程--lambda表达式对比匿名内部类
从前面的整理中我们看出了,Lambda表达式其实是匿名内部类的一种简化,因此它可以部分取代匿名内部类. 1,Lambda表达式与匿名内部类存在如下相同点: 1),Lambda表达式与匿名内部类一样,都 ...
- Java SE 之 DAO层接口设计思想
用图说话 好处 1.只需要定义好IBaseDao的接口方法,并只需要实现BaseDaoImpl的方法,而具体的业务类和业务类/接口的方法的基本方法(IBaseDao已定义的)并不需要再考虑实现. 2. ...
- 《Java 8 in Action》Chapter 3:Lambda表达式
1. Lambda简介 可以把Lambda表达式理解为简洁地表示可传递的匿名函数的一种方式:它没有名称,但它有参数列表.函数主体.返回类型,可能还有一个可以抛出的异常列表. 匿名--我们说匿名,是因为 ...
- Effective Java 第三版——43.方法引用优于lambda表达式
Tips <Effective Java, Third Edition>一书英文版已经出版,这本书的第二版想必很多人都读过,号称Java四大名著之一,不过第二版2009年出版,到现在已经将 ...
随机推荐
- 【微服务】- 配置中心 - Nacos
微服务 - 配置中心 - Nacos 一个有梦有戏的人 @怒放吧德德 分享学习心得,欢迎指正,大家一起学习成长! 今天的学习任务就是学习使用Nacos作为配置中心. 努力克制自己,拒绝摆烂! 什么是配 ...
- 复现禅道V16.5的SQL注入(CNVD-2022-42853)
漏洞详情 禅道V16.5未对输入的account参数内容作过滤校验,导致攻击者拼接恶意SQL语句执行. 环境搭建 环境下载:禅道V16.5 下载后双击运行,进入目录运行start.exe 直接访问即可 ...
- 为什么阿里Java开发手册不推荐使用Timestamp
开发手册 不推荐用java.sql.Date.java.sql.Time网上说的文章有很多. 参考文章:一文告诉你Java日期时间API到底有多烂 但为什么不推荐使用java.sql.Timestam ...
- 记Windows的一个存在了十多年的bug
bug Windows有一个bug,持续了十多年,从Windows Visita开始(2007年),一直存在,直到Windows11(2021年)才修复(其实也不叫修复,后面我再具体说),而Windo ...
- PAT甲级英语单词整理
proper 正确 合适 vertex(vertices)顶点 respectively 个别 分别 indices 指标 索引 shipping 运输 incompatible 不相容 oxidiz ...
- Idea运行支付宝网站支付demo踩坑解决及其测试注意事项
一.前言 在一些商城网上中,必不可少的是支付,支付宝和微信比较常见,最近小编也是在研究这一块,看看支付宝怎么进行支付的,支付宝给我们提供了demo和沙箱测试.减少我们的申请的麻烦,公钥和秘钥也比之前方 ...
- [渲染层错误] [jsbridge] invoke remoteDebugInfo fail: too eayly.
1.问题描述 建立新的小程序项目时.控制台报错 [渲染层错误] [jsbridge] invoke remoteDebugInfo fail: too eayly. 2.解决方法 修改调试基础库的版本 ...
- 怎样在vue中隐藏el-form-item中的值、设置输入框的值是只读
1.如何在前端vue中隐藏某一个元素(el-form-item怎样隐藏) 给每项表单项添加一个自己的id名,并用v-model绑定相对应的数据,利用v-if根据上一个表单项的数据值来进行显示或隐藏 & ...
- 沁恒CH32V003F4P6 开发板上手报告和Win10环境配置
CH32V003 沁恒最近推出的低价CH32V003系列, 基于青稞RISC-V2A内核, 48MHz主频, 2KB SRAM, 16KB Flash, 工作电压兼容3.3V和5V. 主要参数如下 S ...
- 各种优化器对比--BGD/SGD/MBGD/MSGD/NAG/Adagrad/Adam
指数加权平均 (exponentially weighted averges) 先说一下指数加权平均, 公式如下: \[v_{t}=\beta v_{t-1}+(1-\beta) \theta_{t} ...