菜鸡学习day23
程序员文章站
2022-03-08 17:24:12
...
菜鸡学习day23
package day23;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.function.Function;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.function.Supplier;
/*
函数式接口
有且只有一个抽象方法的接口,可以有其他方法(默认静态私有)
可以作为方法的参数和返回值类型使用
*/
public class D2301{
public static void main(String[] args) {
//函数式接口作为方法的参数和返回值类型使用
//传递接口的实现类对象
show(new shiXian());
//传递接口的匿名内部类
show(new Function111() {
@Override
public String method01() {
System.out.println("匿名内部类。");
return null;
}
});
//lambda表达式重写方法。
show(()->{
System.out.println("lambda表达式重写方法。");
return null;
});
//优化
String message1 = "AAA";
String message2 = "BBB";
String message3 = "CCC";
showLog(2,()->{//只有当level==1时,字符串才进行拼接,不会造成性能浪费
return message1 + message2 + message3;
});
//如果方法的参数是一个接口,那么可以用lambda表达式传递这个接口的匿名内部类
thread(()->{
System.out.println(Thread.currentThread().getName());
});
//排序优化
String[] s = {"aaa","bbbb","cccccc","d"};
Arrays.sort(s,comparator());
System.out.println(Arrays.toString(s));
//Suppier,get
getString(()->{
return "AAAAAAA";
});
//用Suppier接口作为参数,返回数组最大值
int[] array = {1,3,2,4,5,7,6};
int max = getMax(()->{
int i = 1;
int num = array[0];
while(i < array.length){
if(num <= array[i])
num = array[i];
i++;
}
return num;
});
System.out.println(max);
//Consumer接口,accept
consumer01("AAA",(String str)->{
System.out.println("消费");
});
//Consumer接口,andThen
consumer02("DDFGasddw",
(con1)->{
System.out.println(con1.toUpperCase());//转大写
},(con2)->{
System.out.println(con2.toLowerCase());//转小写
});
//Consumer接口,andThen打印信息
String[] array1 = {"小明,男","小红,女","小周,女"};
daYin(array1,(name)->{
String s1 = name.split(",")[0];
System.out.print("姓名:" + s1); },
(xingBie)->{
String s2 = xingBie.split(",")[1];
System.out.println(";性别:" + s2);
});
//Predicate接口 抽象方法test
boolean b1 = predicate("ABCDE",(str)->{
return str.equals("zzz");
});
System.out.println(b1);
//Predicate接口 默认方法and 条件1 && 条件2
boolean b2 = and1("ABCDEa",(str1)->{
return str1.length() > 5;
},(str2)->{
return str2.contains("a");
});
System.out.println(b2);
//Predicate接口 默认方法or 条件1 || 条件2
boolean b3 = or1("ABCDEFG",(str1)->{
return str1.length() > 5;
},(str2)->{return str2.contains("a");
});
System.out.println(b3);
//Predicate接口 默认方法negate 非 非 条件1
boolean b4 = no1("ABCDE",(str)->{
return str.length() < 3;
});
System.out.println(b4);
//选择数据练习
String[] array4 = {"小明,32","小小红,32","小小小周,17"};
ArrayList<String> list = lianxi(array4,(str)->{
return str.split(",")[0].length() == 3;
},(str)->{
return str.split(",")[1].equals("32");
});
System.out.println(list);
//Function接口 最主要的抽象方法R apply(T t)根据类型T的参数获取类型R的结果
apply1("AAAAA",(str)->{
return str.length();
});
//
zhuanHuan("123",(str)->{
return Integer.parseInt(str);
},(i)->{
return String.valueOf(i);
});
//Function接口实现自定义函数模型拼接
lianXi("小周,17",(str)->{
return str.split(",")[1];
},(str)->{
return Integer.parseInt(str);
},(i)->{
return i + 100;
});
}
//方法参数为函数式接口
public static void show(Function111 fun){
fun.method01();
}
//优化
public static void showLog(int level,Function111 fun){
if(level == 1){
System.out.println(fun.method01());
}
}
public static void thread(Runnable run){
new Thread(run).start();//开启多线程
}
//如果方法返回值是一个函数式接口,则可返回lambda表达式
public static Comparator<String> comparator(){
return (String str1,String str2)->{
System.out.println("重写。");
return str2.length() - str1.length();
};
}
//Supplier<T>接口包含一个无参的方法 T get(),用来获取一个泛型参数指定类型的对象数据
//生产型接口,知道那个接口的泛型是什么类型,那么接口中的get方法就会产生什么类型的数据
public static String getString(Supplier<String> sup){
return sup.get();
}
//求数组元素最大值
public static int getMax(Supplier<Integer> sup){
return sup.get();
}
//Consumer<T>接口 方法accept
//消费型接口,那个接口的泛型是什么类型,那么接口中的accept方法就会使用什么类型的数据
public static void consumer01(String str,Consumer<String> con){
con.accept(str);
}
//Consumer的方法andThen
//需要两个接口,可以把两个接口组合到一起对数据进行消费,谁写前面就先消费
public static void consumer02(String str, Consumer<String> con1,Consumer<String>con2){
con1.andThen(con2).accept(str);
}
public static void daYin(String[] array,Consumer<String> name,Consumer<String> xingBie){
for(String str : array){
name.andThen(xingBie).accept(str);
}
}
//predicate接口 对某种数据类型的数据进行判断,结果返回一个boolean值
// 有一个抽象方法 boolean text(T t)用来对指定数据类型数据进行判断
public static boolean predicate(String str,Predicate pre){
return pre.test(str);
}
//predicate接口 默认方法 and
public static boolean and1(String str,Predicate<String> pre1,Predicate<String> pre2){
return pre1.and(pre2).test(str);
}
//predicate接口 默认方法 or
public static boolean or1(String str,Predicate<String> pre1,Predicate<String> pre2){
return pre1.or(pre2).test(str);
}
//predicate接口 默认方法 negate 非 取反
public static boolean no1(String str,Predicate<String> pre1){
return pre1.negate().test(str);
}
//
public static ArrayList<String> lianxi(String[] array,Predicate<String> pre1,Predicate<String> pre2){
ArrayList<String> list = new ArrayList<>();
for(String str : array){
if(pre1.and(pre2).test(str)){
list.add(str);
}
}
return list;
}
//Function接口 转换 用来根据一个类型的数据得到另一个类型的数据
//前者为前置条件,后者为后置条件
//最主要的抽象方法R apply(T t)根据类型T的参数获取类型R的结果
public static void apply1(String str,Function<String, Integer> fun){
Integer i = fun.apply(str);
System.out.println(i);
}
//练习
//将String类型的“123”转换为Integer类型123,然后+10,转换为String类型“133”
public static void zhuanHuan(String str,Function<String,Integer> fun1,Function<Integer,String> fun2){
Integer i = fun1.apply(str) + 10;
System.out.println(i);
String str2 = fun2.apply(i);
System.out.println(str2.toString());
}
//Function接口实现自定义函数模型拼接
//字符串截取年龄部分,得到字符串,转换为int类型数字,+100得到结果int数字
public static void lianXi(String str,Function<String,String> fun1,Function<String,Integer> fun2,Function<Integer,Integer> fun3){
Integer i =fun1.andThen(fun2).andThen(fun3).apply(str);
System.out.println(i);
}
}
package day23;
@FunctionalInterface//检测是否是函数式接口
public interface Function111 {
//定义一个抽象方法
public abstract String method01();
}
package day23;
public class shiXian implements Function111 {
@Override
public String method01(){
System.out.println("实现类重写方法。");
return null;
}
}