概念
函数式接口在Java中是指：有且仅有一个抽象方法的接口。
语法糖：使用更加方便，原理不变的代码语法。
本节主要介绍的函数式接口有
runnable，supplier，consumer，predicate，function。
函数式接口与匿名内部类的区别：
匿名内部类会产生class文件，函数式接口不会
函数式编程
lambda的延迟执行
日志案例
函数式编程提高效率
public class Demo01Logger {
public static void main(String[] args) {
String msg1 = "Hello";
String msg2 = "World";
String msg3 = "Java";
showLog(2,()->{
System.out.println("执行了");
//正常的会先进行拼接，再传入方法，现在
return msg1+msg2+msg3;
});
}
public static void showLog(int level,MessageBuilder mb){
if (level==1){
System.out.println(mb.builderMessage());
}
}
}
函数式接口作为方法的参数
public class Demo01Test {
public static void main(String[] args) {
startThread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"线程启动了！");
}
});
startThread(()->{
System.out.println(Thread.currentThread().getName()+"线程启动了！");
});
}
public static void startThread(Runnable run) {
new Thread(run).start();
}
}
函数式接口作为方法的返回值
public class Demo02Test {
public static void main(String[] args) {
String[] arr = {"a","bbb","cc"};
Arrays.sort(arr,getComparator());
System.out.println(Arrays.toString(arr));
}
public static Comparator<String> getComparator(){
/* return new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return o2.length()-o1.length();
}
};*/
//return (String o1,String o2)->{return o2.length()-o1.length();};
return (o1,o2)->o2.length()-o1.length();
}
}
常用的函数式接口
public static void main(String[] args) {
//System.out.println(getString(()->{return "fff";}));
System.out.println(getString(()->"fff"));
}
public static String getString(Supplier<String> s) {
return s.get();
}
获取元素的最大值
public static void main(String[] args) {
int[] arr = {3,8,1,2};
int sum = getMax(()->{
//重点是，arr能传进来
int max = arr[0];
for (int i : arr) {
if (max < i) {
max = i;
}
}
return max;
});
System.out.println(sum);
}
public static Integer getMax(Supplier<Integer> i) {
return i.get();
}
Consumer接口
public static void main(String[] args) {
consumer("刘春磊",(s)->{
System.out.println(s+" 26");
String reverse = new StringBuilder(s).reverse().toString();
System.out.println(reverse);
});
}
public static void consumer(String str, Consumer<String> consumer) {
consumer.accept(str);
}
consumer的andthen方法
andthen的例子
public static void main(String[] args) {
String[] strings = {"liu,26","chun,26","lei,26"};
printInfo((s1)->{
System.out.print("姓名："+s1.split(",")[0]);},(s2)->{
System.out.println(" 年龄："+s2.split(",")[1]+".");
},strings);
}
public static void printInfo(Consumer<String> con1,Consumer<String> con2,String[] str){
for (String s : str) {
con1.andThen(con2).accept(s);
}
}
predicate接口
public static void main(String[] args) {
String str = "abc";
System.out.println(checkString(str,(String s)->{
return s.length()>5;
}));
}
public static boolean checkString(String s, Predicate<String> pre) {
return pre.test(s);
}
predicate的and,or,negate方法
public class Demo07Predict {
public static void main(String[] args) {
String str = "abc";
System.out.println(checkString(str,(String s)->{
return s.length()>5;
},(String s)->{ return s.contains("v");}));
}
public static boolean checkString(String s, Predicate<String> pre1,Predicate<String> pre2) {
return pre1.and(pre2).test(s);
}
}
对数组进行条件过滤且返回信息
public class Demo07Predict {
public static void main(String[] args) {
String[] str = {"迪丽热巴,女","古力娜扎,女","马儿扎哈,男","赵丽颖,女"};
ArrayList<String> list = checkString(str, (String s) -> {
return s.split(",")[1].equals("女");
}, (String s) -> {
return s.split(",")[0].length() == 4;
});
System.out.println(list.toString());
}
public static ArrayList<String> checkString(String[] s, Predicate<String> pre1, Predicate<String> pre2) {
ArrayList<String> strings = new ArrayList<>();
for (String s1 : s) {
boolean a = pre1.and(pre2).test(s1);
if (a == true) {
strings.add(s1);
}
}
return strings;
}
}
function接口的apply方法
function接口的andThen方法
public class Demo08Test {
public static void main(String[] args) {
change("4",s->Integer.parseInt(s) +10,integer->integer+"");
}
public static void change(String str, Function<String,Integer> fun1,Function<Integer,String> fun2) {
String apply = fun1.andThen(fun2).apply(str);
System.out.println(apply);
}
}
function接口的自定义函数模型拼接
public class Demo08Test {
public static void main(String[] args) {
String str = "赵丽颖,20";
change(str,s->s.split(",")[1],str1->Integer.parseInt(str1),int1->int1+100);
}
public static void change(String str, Function<String,String> fun1, Function<String, Integer> fun2, Function<Integer,Integer> fun3) {
Integer apply = fun1.andThen(fun2).andThen(fun3).apply(str);
System.out.println(apply);
}
}
stream流
stream流不同于io流，stream流是依托于lambda表达式的。
public class Demo01Test {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("张无忌");
list.add("周芷若");
list.add("赵敏");
list.add("张强");
list.add("张三丰");
ArrayList<String> listA = new ArrayList<>();
for (String s : list) {
if (s.startsWith("张")) {
listA.add(s);
}
}
ArrayList<String> listB = new ArrayList<>();
for (String s : listA) {
if (s.length() == 3) {
listB.add(s);
}
}
for (String s : listB) {
System.out.println(s);
}
}
}
用stream流可以将3个循环操作简化很多。
list.stream()
.filter(name->name.startsWith("张"))
.filter(name->name.length()==3)
.forEach(name-> System.out.println(name));
stream类似于流水线。使用流的一般方式
【重点】lambda的延迟执行特性
stream流
获取stream流的两种方式
1.collection接口的stream方法
2.Stream类中静态方法of
stream流的方法
foreach方法
Stream<String> stream = Stream.of("张三", "李四", "王五", "赵六");
stream.forEach(name-> System.out.println(name));
过滤filter
Stream<String> stream = Stream.of("张三3", "李四", "王五5", "赵六");
stream.filter(name->name.length()>2)
.forEach(a-> System.out.println(a));
stream是一个管道流，只能被使用一次，再次使用的话，会报IllegalStateException异常。
map映射
在写流的时候，apply方法有参数有返回值。
Stream<String> stringStream = Stream.of("1", "45", "3");
stringStream.map(str->Integer.parseInt(str))
.forEach(integer -> System.out.println(integer+10));
stream流的count方法（终结方法）
limit方法，截取前几个元素
skip方法：跳过前几个元素，如果元素不够，得到长度为0的空流
两个流合并concat
集合元素的处理
public class Demo02Test {
public static void main(String[] args) {
ArrayList<String> one = new ArrayList<>();
ArrayList<String> two = new ArrayList<>();
one.add("迪丽热巴");
one.add("宋远桥");
one.add("苏星河");
one.add("石破天");
one.add("石中玉");
one.add("老子");
one.add("庄子");
one.add("洪七公");
two.add("古力娜扎");
two.add("张无忌");
two.add("赵丽颖");
two.add("张三丰");
two.add("尼古拉斯赵四");
two.add("张天爱");
two.add("张二狗");
Stream<String> stream1 = one.stream().filter(name -> name.length() == 3)
.limit(3);
Stream<String> stream2 = two.stream().filter(name -> name.startsWith("张"))
.skip(2);
Stream.concat(stream1,stream2)
.map(s -> new Person(s))
.forEach(name-> System.out.println(name));
}
}
方法引用
基本介绍
在lambda中指定的操作方案已经存在在其他地方，即冗余的lambda场景的处理
public static void main(String[] args) {
//method(s -> System.out.println(s));
method(System.out::println);
}
public static void method(Printable printable) {
printable.print("hello,world!");
}
又省略了参数。
"::"是引用运算符，它所在的表达式被称为“方法引用”。
示例：使用对象名引用成员方法
public class Demo01Test {
public static void main(String[] args) {
//method(s -> System.out.println(s));
method(System.out::println,"fffff");
method((str)->{
MethodRefObject obj = new MethodRefObject();
obj.toUpper(str);
},"fdfd");
MethodRefObject methodRefObject = new MethodRefObject();
method(methodRefObject::toUpper,"gkNNN");
}
public static void method(Printable printable,String s) {
printable.print(s);
}
}
使用类名引用静态方法
public class Demo04Test {
public static void main(String[] args) {
int method = method(k -> Math.abs(k), -5);
method(Math::abs,-4);
System.out.println(method);
}
public static int method(Calcable calcable,int i) {
return calcable.calAbs(i);
}
}
通过super引用父类的成员方法
通过this引用本类的成员方法
//通过super引用父类的成员方法
/*method(()->{
Human human = new Human();
human.sayHello();
});*/
method(this::sayHello);
//通过this引用本类的成员方法
public class Husband {
public void buyHouse(){
System.out.println("买一套房");
}
public void marry(Richable r){
r.buy();
}
public void soHappy(){
/*marry(()->{
Husband husband = new Husband();
husband.buyHouse();
});*/
marry(this::buyHouse);
}
public static void main(String[] args) {
new Husband().soHappy();
}
}
类的构造方法引用
数组的构造器引用
public class Demo06Test {
public static int[] createArray(int length, ArrayBuilder ab){
return ab.builderArray(length);
}
public static void main(String[] args) {
int len = 5;
createArray(len,(int length)->{
return new int[length];
});
createArray(len,int[]::new);
}
}
5073
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
