一、函数式接口介绍

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表达式)的更多相关文章

  1. [二] java8 函数式接口详解 函数接口详解 lambda表达式 匿名函数 方法引用使用含义 函数式接口实例 如何定义函数式接口

    函数式接口详细定义 package java.lang; import java.lang.annotation.*; /** * An informative annotation type use ...

  2. 函数式编程/lambda表达式入门

    函数式编程/lambda表达式入门 本篇主要讲解 lambda表达式的入门,涉及为什么使用函数式编程,以及jdk8提供的函数式接口 和 接口的默认方法 等等 1.什么是命令式编程 命令式编程就是我们去 ...

  3. Python爬虫与数据分析之进阶教程:文件操作、lambda表达式、递归、yield生成器

    专栏目录: Python爬虫与数据分析之python教学视频.python源码分享,python Python爬虫与数据分析之基础教程:Python的语法.字典.元组.列表 Python爬虫与数据分析 ...

  4. Java1.8新特性——接口改动和Lambda表达式

    Java1.8新特性——接口改动和Lambda表达式 摘要:本文主要学习了Java1.8的新特性中有关接口和Lambda表达式的部分. 部分内容来自以下博客: https://www.cnblogs. ...

  5. Java 8新特性(一):Lambda表达式

    2014年3月发布的Java 8,有可能是Java版本更新中变化最大的一次.新的Java 8为开发者带来了许多重量级的新特性,包括Lambda表达式,流式数据处理,新的Optional类,新的日期和时 ...

  6. 6.1 接口 - 6.3 lambda表达式

    6.1 接口 接口概念 接口是对类的一组需求描述,这些类要遵从接口描述的统一格式进行定义.设计目的是解决多继承的问题 接口中所有方法时 public 不用现实声明 java.lang.Comparab ...

  7. 函数式编程--lambda表达式对比匿名内部类

    从前面的整理中我们看出了,Lambda表达式其实是匿名内部类的一种简化,因此它可以部分取代匿名内部类. 1,Lambda表达式与匿名内部类存在如下相同点: 1),Lambda表达式与匿名内部类一样,都 ...

  8. Java SE 之 DAO层接口设计思想

    用图说话 好处 1.只需要定义好IBaseDao的接口方法,并只需要实现BaseDaoImpl的方法,而具体的业务类和业务类/接口的方法的基本方法(IBaseDao已定义的)并不需要再考虑实现. 2. ...

  9. 《Java 8 in Action》Chapter 3:Lambda表达式

    1. Lambda简介 可以把Lambda表达式理解为简洁地表示可传递的匿名函数的一种方式:它没有名称,但它有参数列表.函数主体.返回类型,可能还有一个可以抛出的异常列表. 匿名--我们说匿名,是因为 ...

  10. Effective Java 第三版——43.方法引用优于lambda表达式

    Tips <Effective Java, Third Edition>一书英文版已经出版,这本书的第二版想必很多人都读过,号称Java四大名著之一,不过第二版2009年出版,到现在已经将 ...

随机推荐

  1. Docker和containerd在容器日志及相关参数配置方面的一些差异

  2. 9. 第八篇 kube-controller-manager安装及验证

    文章转载自:https://mp.weixin.qq.com/s?__biz=MzI1MDgwNzQ1MQ==&mid=2247483826&idx=1&sn=88f0cef6 ...

  3. Elasticsearch:significant terms aggregation

    在本文中,我们将重点关注significant terms和significant text聚合.这些聚合旨在搜索数据集中有趣和/或不寻常的术语,这些术语可以告诉您有关数据的隐藏属性的更多信息.此功能 ...

  4. MongoDB 分片集群的用户和权限一般操作步骤

    步骤总结: 按照mongos路由.配置副本集服务,分片副本集服务的先后顺序关闭所有节点服务 创建副本集认证的key文件,复制到每个服务所在目录 修改每个服务的配置文件,增加参数 启动每个服务 创建账号 ...

  5. PR中导入的照片在画面上只显示一部分的解决办法

    这是因为图片的分辨率太大导致的. 1.图片的分辨率大于PR工程的设置的时候,就会只显示局部. 2.可以用PS把图片先缩小为工程大小即可. 3.也可以把图片拖到时间线上,右键点击,缩放为帧大小即可. 这 ...

  6. 轻松绕过waf,内网技术,Cobalt Strike4.4远控木马绕waf流量监控

    DNS隧道技术可以解决运控木马无法上线的问题,waf,防火墙对tcp,http,https等端口有流量检测,这个时候我们就可以使用隧道技术,让cs木马走DNS隧道,不仅可以检测不到而且也是一种反溯源的 ...

  7. 实验02_Proteus仿真数码管显示报告

    一.原理总结   利用两个寄存器 R4 和 R5 来存储两个数码管的显示数字,R4 用来存储前一个数码管显示数字,而 R5 用来存储后一个数码管显示数字,利用左移操作 RLC 取 A 中首位放入 C ...

  8. C#-01 关于C#中传入参数的一些用法

    实验环境 实验所处环境位于vs2019环境中 学习内容 一.最基础的参数传入:值参数 对于这种传入,和其他的c,c++编程语言参数传入一样,没有太大差别,在这里给如下例子: 虽然这里并没有进行传参但是 ...

  9. 洛谷P1216 [USACO1.5][IOI1994]数字三角形 Number Triangles (DP入门)

    考虑逆推就行了. 1 #include<bits/stdc++.h> 2 using namespace std; 3 int n; 4 int a[1010][1010]; 5 int ...

  10. 通过 Github Action 实现定时推送天气预报

    偶然间,看到 GitHub Actions 教程:定时发送天气邮件 - 阮一峰的网络日志 这篇文章,没错,这个正好能打发自己的折腾之心,也能通过代码给生活引入一些变化. 还是在这里简单记录一下实现过程 ...