常用函数接口
函数式接口——————有且只有一个抽象方法的接口，称之为函数式接口。
当然接口中可以包含其他的方法（默认，静态，私有）。
@FunctionalInterface注解
作用—————————可以检测接口是否是一个函数式接口
是————编译成功
否————编译失败（接口中没有抽象方法，抽象方法的个数多余一个）
函数式接口的使用———一般可以作为方法的参数和返回值类型
性能浪费的日志案例
package cn.lrf.lambdaDemo;
/*日志案例
* 发现以下代码存在的一些性能浪费的问题
* 调用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 mgs1 = "Hello";
String mgs2 = "World";
String mgs3 = "Java";
//调用showLog方法，传递日志级别和日志信息
showLog(1,mgs1+mgs2+mgs3);
}
}
使用Lambda优化日志案例
package cn.lrf.lambdaDemo;
/*使用Lambda优化日志案例
* Lambda的特点————————延迟加载
* Lambda的使用前提，必须存在函数式接口*/
public class Demo02Lambda {
//显示日志信息的方法，方法的参数传递日志的等级和MessageBuilder接口
public static void showLog(int level, MessageBuilder mb) {
//对日志等级进行判断，如果是1级别，则调用MessageBuilder接口中的builderMessage方法
if (level == 1) {
System.out.println(mb.builderMessage());
}
}
public static void main(String[] args) {
//定义三个日志信息
String mgs1 = "Hello";
String mgs2 = "World";
String mgs3 = "Java";
//调用showLog方法，参数MessageBuilder是一个函数式接口，所以可以传递Lambda表达式
showLog(2, () -> {
//返回一个拼接好的字符串
return mgs1 + mgs2 + mgs3;
});
/*使用Lambda表达式作为参数传递，仅仅是把参数传递到showLog方法中
* 只有满足条件，日志的等级是1级
* 才会调用MessageBuilder接口中的方法builderMessage
* 才会进行字符串的拼接
* 如果条件不满足，日志等级不是1级
* 那么MessageBuilder接口中的方法builderMessage也不会执行
* 所以拼接字符串的代码也不会执行
* 所以不会存在性能的浪费*/
}
}
package cn.lrf.lambdaDemo;
@FunctionalInterface
public interface MessageBuilder {
//定义一个拼接消息的抽象方法，返回被拼接的消息
public abstract String builderMessage();
}
函数式接口作为方法的参数案例
package cn.lrf.hanShu;
/*假如java.lang.Runnable接口就是一个函数式接口，
* 假设有一个startThread方法使用该接口作为参数，那么就可以使用Lambda参数进行传参。
* 这种情况其实和Thread类的构造方法参数为Runnable没有本质区别*/
public class Demo01Runnable {
//一个startThread方法，方法参数使用函数式接口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()+"-->线程启动了");
}
});
//调用startThread方法，方法的参数是一个函数式接口，所以可以传递Lambda表达式
startThread(()->{
System.out.println(Thread.currentThread().getName()+"-->线程启动了");
});
//优化Lambda表达式
startThread(()->System.out.println(Thread.currentThread().getName()+"-->线程启动了")
);
}
}
函数式接口作为方法的返回值
package cn.lrf.hanShu;
import java.util.Arrays;
import java.util.Comparator;
/*如果一个方法的返回值类型是一个函数式接口，那么就可以直接返回一个Lambda表达式
* 当需要通过一个方法来获取一个java.util.Comparator接口类型的对象作为排序器时，就可以调用该方法获取*/
public class Demo02Comparator {
//定义一个方法，方法的返回值类型使用函数式接口Comparator
public static Comparator getComparator() {
/* //方法的返回值类型是一个接口，那么我们可以返回这个接口的匿名内部类
return new Comparator() {
@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","cccccccccccc","dddddddddddd"};
//输出排序前的数组
System.out.println(Arrays.toString(arr));//[aaa, b, cccccccccccc, dddddddddddd]
//调用Arrays.sort方法，对数组进行排序
Arrays.sort(arr,getComparator());
//输出排序后的数组
System.out.println(Arrays.toString(arr));//[cccccccccccc, dddddddddddd, aaa, b]
}
}
常用的函数式接口———Supplier接口
package cn.lrf.hanShu;
import java.util.function.Supplier;
/*常用的函数式接口
* java.util.function.Supplier接口仅包含一个无参的方法：T get()。用来获取一个泛型参数指定类型的对象数据。
* Supplier接口被称之为生产型接口，指定接口泛型是什么类型，那么接口中的get方法就会生产什么类型的数据*/
public class Deno01Supplier {
//定义一个方法，方法的参数床底Supplier接口，泛型执行String,get方法就会放回一个String
public static String getString(Supplier 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(() -> "胡歌");
System.out.println(s2);
}
}
练习————常用的函数式接口Supplier接口
package cn.lrf.hanShu;
import java.util.function.Supplier;
/*练习
* 求数组元素最大值
* 使用Supplier接口作为方法参数类型，通过Lambda表达式求出int数组中的最大值。
* 提示——————接口的泛型请使用java.lang.Integer类*/
public class Demo01Test {
//定义一个方法，用于获取int类型数组中元素的最大值，方法的参数传递Supplier接口，泛型使用Integer
public static int getMax(Supplier sup) {
return sup.get();
}
public static void main(String[] args) {
//定义一个int类型的数组，并赋值
int[] arr = {100, 0, -50, 888, 99, 33, -33};
//调用getMax方法，方法的参数Supplier是一个函数式接口，所以传递Lambda表达式
int maxVaule=getMax(() -> {
//获取数组的最大值并返回
//定义一个变量，把数组中的第一个元素赋值给该变量，记录数组中元素的最大值
int max = arr[0];
//遍历数组，获取数组中的其他元素
for (int i : arr) {
//使用其他元素和最大值比较
if (i > max) {
//如果i大于max，则替换max作为最大值
max = i;
}
}
return max;
});
System.out.println("数组中元素的最大值时："+maxVaule);
}
}
常用的函数式接口——Consumer接口
package cn.lrf.hanShu;
import java.util.function.Consumer;
/*java.util.function.Comsumer接口则正好于Supplier接口相反，
* 它不是生产一个数据，而是消费一个数据，其数据类型由泛型决定。
* Consumer接口中包含抽象方法void accept（T t）,意为消费一个指定泛型的数据。
* 至于具体怎么消费（使用），需要自定义（输出，计算...）*/
public class Demo01Comsumer {
/*
* 定义一个方法
* 方法的参数传递一个字符串的姓名
* 方法的参数传递一个Consumer接口消费字符串的姓名*/
public static void method(String name, Consumer con) {
con.accept(name);
}
public static void main(String[] args) {
//调用method方法，传递字符串姓名，方法的另一个参数是Consumer，是一个函数式接口，所以可以传递一个Lambda表达式
method("赵丽颖", (String name) -> {
//对传递的字符串进行消费
//消费方式————直接输出字符串
// System.out.println(name);
//消费方式————把字符串进行反转输出
String reName=new StringBuffer(name).reverse().toString();
System.out.println(reName);
});
}
}
常用的函数式接口——Consumer接口
package cn.lrf.hanShu;
/*Consumer接口的默认方法andThen
* 作用————需要两个Consumer接口，可以把两个Consumer接口组合到一起，在对数据进行消费
* 例如
* Consumer con1
* Consumer con2
* String s="hello*
* con1.accpet(s)
* con2.accpet(s)
* 连接两个Consumer接口 在进行消费
* con1.andThen(con2).accpet(s);谁写在前面谁先消费
*/
import java.util.function.Consumer;
public class Demo02AndThen {
//定义一个方法，方法的参数传递一个字符串和两个Consumer接口，Comsumer接口的泛型使用字符串
public static void method(String s, Consumer con1, Consumer con2) {
// con1.accept(s);
//con2.accept(s);
//使用andThen方法，把两个consumer接口连接到一起，在消费数据
con1.andThen(con2).accept(s);//con1连接con2，先执行con1消费数据，在执行con2消费数据
}
public static void main(String[] args) {
//调用method方法，传递一个字符串两个Lambda表达式
method("Hello",
(t) -> {
//消费方式————把字符串转换为大写输出
System.out.println(t.toUpperCase());
},
(t) -> {
//消费方式————把字符串转换为小写输出
System.out.println(t.toLowerCase());
});
}
}
练习————常用的函数式接口Consumer接口
package cn.lrf.hanShu;
import java.util.function.Consumer;
/*练习
* 字符串数组当中存有多条信息，请按照格式”姓名：XX。性别：XX“的格式将信息打印出来。
* 要求将打印性别的动作作为第二个Consumer接口的labmbda实例，
* 将两个Consumer接口按照顺序”拼接“到一起*/
public class Demo03 {
//定义一个方法，参数传递String类型的数组和两个Consumer接口，泛型使用String
public static void pintInfo(String[] arr, Consumer con1, Consumer con2) {
//遍历字符串数组
for (String message : arr) {
//使用andThen方法连接两个Consumer接口，消费字符串
con1.andThen(con2).accept(message);
}
}
public static void main(String[] args) {
//定义一个字符串类型的数组
String[] arr = {"迪丽热巴,女", "古力娜扎,女", "马儿扎哈,男"};
//调用pringtInfo方法，传递一个字符串数组，和两个Lambda表达式
pintInfo(arr, (message) -> {
//消费方式——————对message进行切割，获取姓名，按照指定格式输出
String name = message.split(",")[0];
System.out.print("姓名：" + name);
},
(message) -> {
//消费方式——————对message进行切割，获取年龄，按照指定格式输出
String age = message.split(",")[1];
System.out.println("。年龄：" + age+"。");
});
}
}
常用的函数式接口——Predicate接口
package cn.lrf.hanShu;
import java.util.function.Predicate;
/*java.util.fuction.Predicater接口
作用————对某种数据类型的数据进行判断，结果返回一个boolean值。
Predicate接口中包含一个抽象方法
boolean test (T t)————用来对指定数据类型进行判断的方法。
结果
符合条件，返回true
不符合条件，返回false*/
public class Demo01Predicate {
/*定义一个方法
* 参数传递一个String类型的字符串
* 传递一个Predicate接口，泛型使用String
* 使用Predicate中的方法test对字符串进行判断，并把判断的结果返回*/
public static boolean checkString(String s, Predicate 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;
});
System.out.println(b);
}
}
逻辑表达式——————可以连接多个判断的条件
&&————与运算符，有false则false
||—————或运算符，有true则true
！—————非（取反）运算符，非假则真，非真则假
需求————判断一个字符串，有两个判断的条件
1.判断字符串的长度是否大于5
2.判断字符串中是否包含a
- 两个条件必须同时满足，我们就可以使用&&运算符连接两个条件。
Predicate接口中有一个方法and,表示并且关系，也可以用于连接两个判断条件
default Predicateand(Predicateother){
return(t)->this.test(t)&&other.test(t);
}
方法内部的两个判断条件，也是使用&&运算符连接起来的 。
需求————判断一个字符串，有两个判断的条件
1.判断字符串的长度是否大于5
2.判断字符串中是否包含a
- 满足一个条件即可，我们就可以使用||运算符连接两个条件。
Predicate接口中有一个方法or,表示或者关系，也可以用于连接两个判断条件
default Predicateand(Predicateother){
return(t)->this.test(t)||other.test(t);
}
方法内部的两个判断条件，也是使用||运算符连接起来的 。
需求————判断一个字符串长度是否大于5
1.如果字符串的长度大于5，那么返回false。
2.如果字符串的长度不大于5，那么返回true。
- 我们就可以使用取反符号！对判断的结果进行取反。
Predicate接口中有一个方法negate,也表示取反
default Predicatenegate(){
return(t)->！test(t);
}
常用的函数式接口——Function接口
java.util.function.Function
- Function接口中最主要的抽象方法——R applay(T t),根据类型T的参数获取类型R的结果。
使用的场景例如————将String类型转换为Integer类型。
- Function接口中的默认方法andThen——用来进行组合操作
需求
把String类型的“123”，转换为Integer类型，把转换后的结果加10。
把增加之后的Integer类型的数据，转换为String类型。