黑马就业班（01.JavaSE Java语言基础-10.JDK新特性）——JDK新特性：函数式接口/函数式编程

最新推荐文章于 2025-06-23 20:50:58 发布
原创 最新推荐文章于 2025-06-23 20:50:58 发布 · 288 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文介绍了Java中的函数式接口概念，包括@FunctionalInterface注解，自定义函数接口的使用。讨论了函数式编程，特别是Lambda表达式的延迟执行特性，以及如何用Lambda替换匿名内部类。还探讨了Java提供的常用函数式接口，如Supplier、Consumer、Predicate和Function，并给出了相关练习示例。
对于Lambda表达式，只要记住其针对的是接口抽象方法即可，()里面放的是抽象方法的参数，-> {}， {}中放的是抽象方法的实现语句

  
  
1、函数式接口
1.1 概念
  函数式接口在Java中是指：有且仅有一个抽象方法的接口。 函数式接口，即适用于函数式编程场景的接口。而Java中的函数式编程体现就是Lambda，所以函数式接口就是可以适用于Lambda使用的接口。只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利地进行推导。

备注：“语法糖”是指使用更加方便，但是原理不变的代码语法。例如在遍历集合时使用的for-each语法，其实底层的实现原理仍然是迭代器，这便是“语法糖”。从应用层面来讲，Java中的Lambda可以被当做是匿名内部类的“语法糖”，但是二者在原理上是不同的。

1.2 格式
  只要确保接口中有且仅有一个抽象方法即可：

修饰符 interface 接口名称 
{
	public abstract 返回值类型 方法名称(可选参数信息);
// 其他非抽象方法内容
}

  由于接口当中抽象方法的 public abstract 是可以省略的，所以定义一个函数式接口很简单：

public interface MyFunctionalInterface
{
	void myMethod();
}

1.3 @FunctionalInterface注解
  与 @Override 注解的作用类似，Java 8中专门为函数式接口引入了一个新的注解： @FunctionalInterface 。该注解可用于一个接口的定义上：

@FunctionalInterface注解
    作用:可以检测接口是否是一个函数式接口
        是:编译成功
        否:编译失败(接口中没有抽象方法抽象方法的个数多于1个
        
@FunctionalInterface
public interface MyFunctionalInterface 
{
	void myMethod();
}

  一旦使用该注解来定义接口，编译器将会强制检查该接口是否确实有且仅有一个抽象方法，否则将会报错。需要注意的是，即使不使用该注解，只要满足函数式接口的定义，这仍然是一个函数式接口，使用起来都一样。
  Override注解

    @Override注解
    检查方法是否为重写的方法
        是:编译成功
        否:编译失败

1.4 自定义函数接口的使用
  对于刚刚定义好的 MyFunctionalInterface 函数式接口，典型使用场景就是作为方法的参数：

public class Demo09FunctionalInterface 
{
	// 使用自定义的函数式接口作为方法参数
	private static void doSomething(MyFunctionalInterface inter) 
	{
		inter.myMethod(); // 调用自定义的函数式接口方法
	}
	
	public static void main(String[] args) 
	{
		// 调用使用函数式接口的方法
		doSomething(() ‐> System.out.println("Lambda执行啦！"));
	}
}

2、函数式编程
  在兼顾面向对象特性的基础上，Java语言通过Lambda表达式与方法引用等，为开发者打开了函数式编程的大门。

2.1 Lambda的延迟执行
  有些场景的代码执行后，结果不一定会被使用，从而造成性能浪费。而Lambda表达式是延迟执行的，这正好可以作为解决方案，提升性能。
（匿名内部类在编译的时候会产生一个内部类的“.class”文件，而Lambda表达式则没有类似的文件产生）

性能浪费的日志案例
  注:日志可以帮助我们快速的定位问题，记录程序运行过程中的情况，以便项目的监控和优化。
  一种典型的场景就是对参数进行有条件使用，例如对日志消息进行拼接后，在满足条件的情况下进行打印输出：

public class Demo01Logger {
	private static void log(int level, String msg)
	 {
		if (level == 1) 
		{
			System.out.println(msg);
		}
	}
	public static void main(String[] args)
	 {
		String msgA = "Hello";
		String msgB = "World";
		String msgC = "Java";
		log(1, msgA + msgB + msgC);
	}
}

  这段代码存在问题：无论级别是否满足要求，作为 log 方法的第二个参数，三个字符串一定会首先被拼接并传入方法内，然后才会进行级别判断。如果级别不符合要求，那么字符串的拼接操作就白做了，存在性能浪费。

  备注：SLF4J是应用非常广泛的日志框架，它在记录日志时为了解决这种性能浪费的问题，并不推荐首先进行字符串的拼接，而是将字符串的若干部分作为可变参数传入方法中，仅在日志级别满足要求的情况下才会进行字符串拼接。
  例如： LOGGER.debug(“变量{}的取值为{}。”,“os”,“macOS”) ，其中的大括号 {} 为占位符。如果满足日志级别要求，则会将“os”和“macOS”两个字符串依次拼接到大括号的位置；否则不会进行字符串拼接。这也是一种可行解决方案，但Lambda可以做到更好。

Lambda的更优写法
（注意，Lambda表达式是接口内抽象方法的缩写，与接口无关，我们只需要关注抽象方法的参数与其语句，然后将抽象方法参数与语句修改为Lambda表达式即可。如果实在想不出Lambda表达式怎么写，可以先用匿名内部类实现再转换）
  使用Lambda必然需要一个函数式接口：

@FunctionalInterface
public interface MessageBuilder 
{
	String buildMessage();
}

  然后对 log 方法进行改造：

public class Demo02LoggerLambda 
{
	private static void log(int level, MessageBuilder builder) 
	{
		if (level == 1) 
		{
			System.out.println(builder.buildMessage());
		}
	}
	public static void main(String[] args) 
	{
		String msgA = "Hello";
		String msgB = "World";
		String msgC = "Java";
		log(1, () ‐> msgA + msgB + msgC );
	}
}

  上面这段代码如果使用匿名内部类，也是可以实现的。注意对比依稀匿名内部类与Lambda表达式的不同之处

public class Demo02LoggerLambda 
{
	private static void log(int level, MessageBuilder builder) 
	{
		if (level == 1) 
		{
			System.out.println(builder.buildMessage());
		}
	}
	public static void main(String[] args) 
	{
		String msgA = "Hello";
		String msgB = "World";
		String msgC = "Java";
		log(1, new MessageBuilder()//这里插入其他参数，匿名内部类的buildMessage()方法同样无法执行。也可以达到和Lambda表达式同样的效果。
        {
            @Override
            public String buildMessage()
            {
                return msgA + msgB + msgC;
            }
        });
	}
}

证明Lambda的延迟
  下面的代码可以通过结果进行验证：

public class Demo02LoggerLambda 
{
	private static void log(int level, MessageBuilder builder) 
	{
		if (level == 1) 
		{
			System.out.println(builder.buildMessage());
		}
	}
	public static void main(String[] args) 
	{
		String msgA = "Hello";
		String msgB = "World";
		String msgC = "Java";
		log(2,{
			System.out.println("Lambda执行！");
			return msgA + msgB + msgC;
		} );
	}
	}
}

  从结果中可以看出，在不符合级别要求的情况下，Lambda将不会执行。从而达到节省性能的效果。实际上使用内部类也可以达到同样的效果，只是将代码操作延迟到了另外一个对象当中通过调用方法来完成。而是否调用其所在方法是在条件判断之后才执行的。

2.2 使用Lambda作为参数和返回值
  如果抛开实现原理不说，Java中的Lambda表达式可以被当作是匿名内部类的替代品。如果方法的参数是一个函数式接口类型，那么就可以使用Lambda表达式进行替代。使用Lambda表达式作为方法参数，其实就是使用函数式接口作为方法参数。
  例如 java.lang.Runnable 接口就是一个函数式接口，假设有一个 startThread 方法使用该接口作为参数，那么就可以使用Lambda进行传参。这种情况其实和 Thread 类的构造方法参数为 Runnable 没有本质区别。

public class Demo04Runnable 
{
	private static void startThread(Runnable task) 
	{
		new Thread(task).start();
	}
	public static void main(String[] args) 
	{
		startThread(() ‐> System.out.println("线程任务执行！"));
	}
}

  上面也可以用匿名内部类表示

public class Demo04Runnable 
{
	private static void startThread(Runnable task) 
	{
		new Thread(task).start();
	}
	public static void main(String[] args) 
	{
		startThread(new Runnable(){
			public void run()
			{
				System.out.println("线程任务执行！")
			}
		});
	}
}

  类似地，如果一个方法的返回值类型是一个函数式接口，那么就可以直接返回一个Lambda表达式。当需要通过一个方法来获取一个 java.util.Comparator 接口类型的对象作为排序器时,就可以调该方法获取。

import java.util.Arrays;
import java.util.Comparator;
public class Demo06Comparator {
	private static Comparator<String> newComparator() 
	{
		return (a, b) ‐> b.length() ‐ a.length();
	}
	public static void main(String[] args) 
	{
		String[] array = { "abc","ab","abcd" };
		System.out.println(Arrays.toString(array));
		Arrays.sort(array, newComparator());
		System.out.println(Arrays.toString(array));
	}
}

  上面也可以用匿名内部类表示

import java.util.Arrays;
import java.util.Comparator;
public class Demo06Comparator {
	private static Comparator<String> newComparator() 
	{
		return new Comparator<String>()
		{
			@Override
            public int compare(String a, String b) {
                return b.length() ‐ a.length();
            }
		};
	}
	public static void main(String[] args) 
	{
		String[] array = { "abc","ab","abcd" };
		System.out.println(Arrays.toString(array));
		Arrays.sort(array, newComparator());//当然也可以在这里直接使用匿名内部类
		System.out.println(Arrays.toString(array));
	}
}

3、常用函数式接口
  JDK提供了大量常用的函数式接口以丰富Lambda的典型使用场景，它们主要在 java.util.function 包中被提供。下面是最简单的几个接口及使用示例。

3.1 Supplier接口
  java.util.function.Supplier 接口仅包含一个无参的方法： T get() 。用来获取一个泛型参数指定类型的对象数据。由于这是一个函数式接口，这也就意味着对应的Lambda表达式需要“对外提供”一个符合泛型类型的对象数据。

import java.util.function.Supplier;

public class SupplierTest
{
    private static String getString(Supplier<String> func)
    {
        return func.get();
    }

    public static void main(String[] args)
    {
        String msgA = "Hello";
        String msgB = "World";
        /*
        System.out.println(getString(new Supplier<String>()
        {
            @Override
            public String get()
            {
                return msgA + msgB;
            }
        }));
        */
        //上面这一段也可以写为Lambda表达式
        System.out.println(getString(() -> msgA + msgB));
    }
}

3.2 练习：用Supplier接口求数组元素最大值
  代码如下

package lkj.demo1;

import java.util.function.Supplier;

public class SupplierTest
{
    private static Integer getMax(Supplier<Integer> func)
    {
        return func.get();
    }

    public static void main(String[] args)
    {
        int arr[] = {2,3,4,52,333,23};
        /*
        System.out.println(getMax(new Supplier<Integer>()
        {
            @Override
            public Integer get()
            {
                int max = arr[0];
                for(int i: arr)
                {
                    if(i>max)
                        max = i;
                }
                return max;
            }
        }));
        */
        //上面这一段也可以写为Lambda表达式
        System.out.println(getMax( () -> {
            int max = arr[0];
            for(int i: arr)
            {
                if(i>max)
                    max = i;
            }
            return max;
        }));
    }
}

3.3 Consumer接口
  java.util.function.Consumer 接口则正好与Supplier接口相反，它不是生产一个数据，而是消费一个数据，其数据类型由泛型决定。
  Consumer 接口中包含抽象方法 void accept(T t) ，意为消费一个指定泛型的数据。基本使用如：

package lkj.demo1;

import java.util.function.Consumer;

public class ConsumerTest
{
    private static void consumeString(Consumer<String> func)
    {
        func.accept("hello");
    }

    public static void main(String[] args)
    {
        /*
        consumeString(new Consumer<String>()
        {
            @Override
            public void accept(String s)
            {
                System.out.println(s);
            }
        });
        */
        /*
        consumeString((String s) -> {
            System.out.println(s);
        });
        */
        consumeString(s -> System.out.println(s));
    }
}

  默认方法：andThen：如果一个方法的参数和返回值全都是 Consumer 类型，那么就可以实现效果：消费数据的时候，首先做一个操作，然后再做一个操作，实现组合。而这个方法就是 Consumer 接口中的default方法 andThen 。下面是JDK的源代码：（JDK1.8之后接口可以有默认方法与静态方法，JDK9之后接口还可以有私有方法）

default Consumer<T> andThen(Consumer<? super T> after) 
{
	Objects.requireNonNull(after);
	return (T t) ‐> { accept(t); after.accept(t); };
}
  • 备注： java.util.Objects 的 requireNonNull 静态方法将会在参数为null时主动抛出
    NullPointerException 异常。这省去了重复编写if语句和抛出空指针异常的麻烦。

  要想实现组合，需要两个或多个Lambda表达式即可，而 andThen 的语义正是“一步接一步”操作。例如两个步骤组
合的情况：

package lkj.demo1;

import java.util.function.Consumer;

public class ConsumerTest
{
    private static void consumeString(Consumer<String> one,Consumer<String> two)
    {
        //andThen要和accep方法一起使用，功能其实就是使得第一个Consumer对象one先执行accept方法进行消费
        //随后另一个Consumer对象two接着执行accept方法进行消费。既先做一个再做另一个.
        //这里2个对象的accept方法的内容可以不同，但是2个对象所执行的accept方法的参数是一致的
        one.andThen(two).accept("hello");
    }

    public static void main(String[] args)
    {
        //注意这个方法有2个接口类型的参数，因此要实现2次匿名内部类
        // 这里要注意格式！！！因为要实现2个接口的匿名内部类，看起来比较复杂
        /*
       consumeString(new Consumer<String>()
       {
           @Override
           public void accept(String s)
           {
               System.out.println(s.toUpperCase());
           }
       }, new Consumer<String>()
       {
           @Override
           public void accept(String s)
           {
               System.out.println(s.toLowerCase());
           }
       });
       */
        /*
        consumeString(
                (String s)-> {System.out.println(s.toUpperCase());},
                (String s)-> {System.out.println(s.toLowerCase());}
                );
         */
        consumeString(
                s -> System.out.println(s.toUpperCase()),
                s -> System.out.println(s.toLowerCase())
                );
    }
}

/*
结果
HELLO
hello
 */

3.4 练习：格式化打印信息
  下面的字符串数组当中存有多条信息，请按照格式“ 姓名：XX。性别：XX。
”的格式将信息打印出来。要求将打印姓名的动作作为第一个 Consumer 接口的Lambda实例，将打印性别的动作作为第二个 Consumer 接口的Lambda实例，将两个 Consumer 接口按照顺序“拼接”到一起。

package lkj.demo1;

import java.util.function.Consumer;

public class ConsumerTest
{
    public static void main(String[] args)
    {
        String[] array = { "迪丽热巴,女" , "古力娜扎,女" , "马尔扎哈,男" };
        /*
        printInfo(new Consumer<String>()
        {
            @Override
            public void accept(String s)
            {
                System.out.println("姓名："+s.split(",")[0]);
            }
        }, new Consumer<String>()
        {
            @Override
            public void accept(String s)
            {
                System.out.println("性别："+s.split(",")[1]);
            }
        } , array);
        */
        /*
        printInfo(
                (String s) -> {System.out.println(s.split(",")[0]);},
                (String s) -> {System.out.println(s.split(",")[1]);},
                array
        );
        */
        printInfo(
                s -> System.out.println(s.split(",")[0]),
                s -> System.out.println(s.split(",")[1]),
                array
                );
    }
    private static void printInfo(Consumer<String> one,Consumer<String> two,String[] arr)
    {
        for (String info : arr)
        {
            //这里2个对象的accept方法的内容可以不同，但是2个对象所执行的accept方法的参数是相同的
            one.andThen(two).accept(info);
        }
    }

}

/*
结果
HELLO
hello
 */

3.5 Predicate接口
  有时候我们需要对某种类型的数据进行判断，从而得到一个boolean值结果。这时可以使用java.util.function.Predicate 接口。

抽象方法：test
  Predicate 接口中包含一个抽象方法： boolean test(T t) 。用于条件判断的场景：条件判断的标准是传入的Lambda表达式逻辑，只要字符串长度大于5则认为很长。

package lkj.demo1;

import java.util.function.Predicate;

public class PredicateTest
{
    private static void method(Predicate<String> predicate)
    {
        boolean veryLong = predicate.test("HelloWorld");
        System.out.println("字符串很长吗：" + veryLong);
    }

    public static void main(String[] args)
    {
        /*
        method(new Predicate<String>()
        {
            @Override
            public boolean test(String s)
            {
                return s.length()>5;
            }
        });
        */

//        method((String s) -> {return s.length()>5;});
        
        method(s -> s.length()>5);
    }
}

默认方法：and
  既然是条件判断，就会存在与、或、非三种常见的逻辑关系。其中将两个 Predicate 条件使用“与”逻辑连接起来实现“并且”的效果时，可以使用default方法 and 。其JDK源码为：

default Predicate<T> and(Predicate<? super T> other) 
{
	Objects.requireNonNull(other);
	return (t) ‐> test(t) && other.test(t);
}

  如果要判断一个字符串既要包含大写“H”，又要包含小写“w”，那么：

package lkj.demo1;

import java.util.function.Predicate;

public class PredicateTest
{
    private static void method(Predicate<String> pre1 , Predicate<String> pre2)
    {
        //2个对象一起调用test方法，且2个对象的test方法的参数相同
        //这里的默认方法and用于判断2个对象的test方法是否全部返回true，
        // 当2个Predicate对象的test方法全部返回true，最后结果才为true
        boolean isValid = pre1.and(pre2).test("Helloworld");
        System.out.println("字符串符合要求吗：" + isValid);

    }

    public static void main(String[] args)
    {
        /*
        method(new Predicate<String>()
        {
            @Override
            public boolean test(String s)
            {
                return s.contains("H");
            }
        }, new Predicate<String>()
        {
            @Override
            public boolean test(String s)
            {
                return s.contains("w");
            }
        });
        */
        method(s -> s.contains("H") , s -> s.contains("w"));
    }
}
//结果：只有2个对象的test方法都返回true，“and”最后的结果才是true

默认方法：or
  与 and 的“与”类似，默认方法 or 实现逻辑关系中的“或”。JDK源码为：

default Predicate<T> or(Predicate<? super T> other) 
{
	Objects.requireNonNull(other);
	return (t) ‐> test(t) || other.test(t);
}

  如果希望实现逻辑“字符串包含大写H或者包含小写"w”，那么代码只需要将“and”修改为“or”名称即可，其他都不变：

package lkj.demo1;

import java.util.function.Predicate;

public class PredicateTest
{
    private static void method(Predicate<String> pre1 , Predicate<String> pre2)
    {
        //2个对象一起调用test方法，且2个对象的test方法的参数相同
        // 当2个Predicate对象的test方法至少有一个返回true，最后结果为true
        boolean isValid = pre1.or(pre2).test("Helloworld");
        System.out.println("字符串符合要求吗：" + isValid);

    }

    public static void main(String[] args)
    {
        /*
        method(new Predicate<String>()
        {
            @Override
            public boolean test(String s)
            {
                return s.contains("H");
            }
        }, new Predicate<String>()
        {
            @Override
            public boolean test(String s)
            {
                return s.contains("w");
            }
        });
        */
        method(s -> s.contains("H") , s -> s.contains("w"));
    }
}
//结果：当2个对象的test方法有一个返回true，“or”最后的结果为true

默认方法：negate
  “与”、“或”已经了解了，剩下的“非”（取反）也会简单。默认方法 negate 的JDK源代码为：

default Predicate<T> negate() 
{
	return (t) ‐> !test(t);
}

  从实现中很容易看出，它是执行了test方法之后，对结果boolean值进行“!”取反而已。一定要在 test 方法调用之前调用 negate 方法，正如 and 和 or 方法一样：

package lkj.demo1;

import java.util.function.Predicate;

public class PredicateTest
{
    private static void method(Predicate<String> pre)
    {
        //这里只有一个Predicate对象，只是对原来test方法判断结果取反
        boolean veryLong = pre.negate().test("Helloworld");
        System.out.println("字符串很长吗：" + veryLong);
    }

    public static void main(String[] args)
    {
        /*
        method(new Predicate<String>()
        {
            @Override
            public boolean test(String s)
            {
                return s.length()<5;
            }
        });
        */
        method(s -> s.length()<5);
    }
}

3.6 练习：集合信息筛选
  数组当中有多条“姓名+性别”的信息如下，请通过 Predicate 接口的拼装将符合要求的字符串筛选到集合ArrayList 中，需要同时满足两个条件：

  1. 必须为女生；
  2. 姓名为4个字。
package lkj.demo1;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;

public class PredicateTest
{
    private static List<String> filter(Predicate<String> pre1 , Predicate<String> pre2 , String[] array)
    {
        List<String> list = new ArrayList<>();
        for(String info : array)
        {
            if(pre1.and(pre2).test(info))
                list.add(info);
        }
        return list;
    }

    public static void main(String[] args)
    {
        String[] array = { "迪丽热巴,女", "古力娜扎,女", "马尔扎哈,男", "赵丽颖,女" };

        //使用2个Predicate对象判断，对info信息进行切割，一个Predicate对象判断性别，另一个判断姓名长度
        //使用and方法，当2个对象都返回true，结果为true

        /*
        //匿名内部类实现
        List<String> list = filter(new Predicate<String>()
        {
            @Override
            public boolean test(String s)
            {
                return "女".equals(s.split(",")[1]);
            }
        }, new Predicate<String>()
        {
            @Override
            public boolean test(String s)
            {
                return s.split(",")[0].length() == 4;
            }
        } , array);
        */

        List<String> list =  filter(
                s -> "女".equals(s.split(",")[1]) ,
                s -> s.split(",")[0].length() == 4 , array);

        System.out.println(list);
    }
}
//结果：[迪丽热巴,女, 古力娜扎,女]

3.7 Function接口
  java.util.function.Function<T,R> 接口用来根据一个类型的数据得到另一个类型的数据，前者称为前置条件，后者称为后置条件。

抽象方法：apply
  Function 接口中最主要的抽象方法为： R apply(T t) ，根据类型T的参数获取类型R的结果。使用的场景例如：将 String 类型转换为 Integer 类型。

package lkj.demo1;

import java.util.function.Function;

public class FunctionTest
{
    private static void method(Function<String,Integer> func)
    {
        int num = func.apply("10");
        System.out.println(num + 20);
    }

    public static void main(String[] args)
    {
        /*
        method(new Function<String, Integer>()
        {
            @Override
            public Integer apply(String s)
            {
                return Integer.parseInt(s);//返回一个Integer类型的数据
            }
        });
        */

//        method((String s) -> {return Integer.parseInt(s);});

        method(s -> Integer.parseInt(s));
    }
}

默认方法：andThen
  Function 接口中有一个默认的 andThen 方法，用来进行组合操作。JDK源代码如：

default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) 
{
	Objects.requireNonNull(after);
	return (T t) ‐> after.apply(apply(t));
}

  该方法同样用于“先做什么，再做什么”的场景，和 Consumer 中的 andThen 差不多：

package lkj.demo1;

import java.util.function.Function;

public class FunctionTest
{
    private static void method(Function<String,Integer> func1,Function<Integer,Integer> func2)
    {
        //这里类似于Consumer对象的andThen方法，但是Consumer是前后2个对象的accept方法的参数相同
        //既前后2个对象执行accept的时候使用同一个参数，但是accept方法中对不同参数的处理不同

        //而Function对象则是第一个对象先处理apply方法的参数，获取一个结果再将结果发回给第二个对象的apply方法，作为第二个对象apply方法的参数
        //第一个Function对象先执行apply方法，操作数据“10”，将String类型的10转换为Integer类型的10
        //接下来第二个Function对象再执行apply方法，将Integer类型的20乘以10转换为Integer类型的200
        int num = func1.andThen(func2).apply("10");
        System.out.println(num + 20);
    }

    public static void main(String[] args)
    {
        /*
        method(new Function<String, Integer>()
        {
            @Override
            public Integer apply(String s)
            {
                return Integer.parseInt(s)+10;//获得Integer类型的结果——20
            }
        }, new Function<Integer, Integer>()
        {
            @Override
            public Integer apply(Integer i)//注意，这里的Integer参数是第一个Function对象处理结果——20
            {
                return i *= 10;
            }
        });
        */

        method(s -> Integer.parseInt(s)+10 , i -> i *= 10);
    }
}

  第一个操作是将字符串解析成为int数字，第二个操作是乘以10。两个操作通过 andThen 按照前后顺序组合到了一起。

  • 请注意，Function的前置条件泛型和后置条件泛型可以相同

3.8 练习：自定义函数模型拼接
题目
请使用 Function 进行函数模型的拼接，按照顺序需要执行的多个函数操作为：
String str = “赵丽颖,20”;

  1. 将字符串截取数字年龄部分，得到字符串；
  2. 将上一步的字符串转换成为int类型的数字；
  3. 将上一步的int数字累加100，得到结果int数字。
package lkj.demo1;

import java.util.function.Function;

public class FunctionTest
{
    private static int getAgeNum(String str , Function<String,String> func1,
                                 Function<String,Integer> func2,
                                 Function<Integer, Integer> func3)
    {
        return func1.andThen(func2).andThen(func3).apply(str);
    }

    public static void main(String[] args)
    {
        String str = "赵丽颖,20";
        /*
        int age = getAgeNum(str, new Function<String, String>()
        {
            @Override
            public String apply(String s)
            {
                return str.split(",")[1];
            }
        }, new Function<String, Integer>()
        {
            @Override
            public Integer apply(String s)
            {
                return Integer.parseInt(s) ;
            }
        }, new Function<Integer, Integer>()
        {
            @Override
            public Integer apply(Integer i)
            {
                return i += 100;
            }
        });
        */
        int age = getAgeNum(str , s -> s.split(",")[1] ,
                            s -> Integer.parseInt(s) ,
                            i -> i += 100);
        System.out.println(age);
    }
}
黑马就业班（01.JavaSE Java语言基础-11.Java基础加强）——基础加强:Junit单元测试、反射、注解
LKJgdut的博客
12-26 697
   1、Junit单元测试 测试分类： 1. 黑盒测试：不需要写代码，给输入值，看程序是否能够输出期望的值。 2. 白盒测试：需要写代码的。关注程序具体的执行流程。 Junit使用：白盒测试 步骤：   1. 定义一个测试类(测试用例) 建议： 测试类名：被测试的类名Test ——CalculatorTest 包名：xxx.xxx.xx.test——cn.itcast.t...
JavaSE基础加强-学习黑马程序员Java基础视频教程（P93开始）
孟孟单单的博客
06-11 2628
JavaSE基础加强
黑马程序员JAVA学习第九节
weixin_51181574的博客
06-23 302
黑马程序员JAVA学习第九节 （视频链接黑马程序员全套Java教程_Java基础入门教程，零基础小白自学Java必备教程_哔哩哔哩 (゜-゜)つロ 干杯~-bilibili） 本节主要内容是函数式接口。对应视频372-。 函数式接口 1.函数式接口概述 1）概念 有且仅有一个抽象方法的接口 2）如何检测一个接口是不是函数式接口 @FunctionalInterface 放在接口定义的上方：如果接口是函数式接口，编译通过；如果不是，编译失败 3）注意事项 我们自己定义函数式接口...
Predicate接口
weixin_44230693的博客
02-18 1476
Predicate接口 有时候我们需要对某种类型的数据进行判断，从而得到一个boolean值结果。这时可以使用 java.util.function.Predicate 接口。 1、抽象方法：test Predicate 接口中包含一个抽象方法： boolean test(T t) 。用于条件判断的场景： /* * Predicate接口中包含一个抽象方法： * boolean test(T t):用来指定数据类型进行判断的方法 * 结果： * 符合条件，返回true *
常用的函数式接口——Predicate接口
weixin_44664432的博客
10-18 3013
Predicate接口： java.util.function.Predicate接口 作用：对某种数据类型的数据进行判断，结果返回一个boolean值 抽象方法：test: Predicate接口中包含了一个抽象方法： boolean test(T t):用来对指定数据类型数据进行判断的方法 结果; 符合条件，返回true 不符合条件，返回false 使用案例： public class Demo01Predicate { /* 定义一个方法 参数传递一个Strin
java Predicate接口
skh2015java的博客
06-27 1803
1. 过滤集合中的元素。像List#removeIf()、Stream#filter()等方法接收Predicate来过滤元素。Predicate是Java中的一个函数式接口,它代表一个判断逻辑,接收一个输入参数,返回一个布尔值。4. 自定义复杂的判断逻辑作为方法的参数。Predicate的使用者无需了解判断逻辑的具体实现细节。2. 判断对象是否满足某条件,作为if语句的判断条件。它接收泛型T的输入,返回true或false。3. 验证对象的一些属性或状态是否正确。
Predicate接口介绍
weixin_56693899的博客
11-20 1271
Predicate接口介绍
黑马毕向东JAVA基础总结笔记.docx
05-03
黑马毕向东的JAVA基础总结笔记是一份全面的文档，详细介绍了Java编程语言的基础知识、语法、以及如何进行有效编程。这份文档强调了在编程之前应清晰地理解需求和分析思路，然后拟定实现方案，并通过具体的Java代码...
2022年黑马毕向东JAVA基础总结笔记.docx
04-22
Java是一种广泛使用的编程语言，它遵循面向对象的设计原则，具备跨平台的特性，这些特性主要得益于Java虚拟机（JVM）的存在。Java的发展历程始于1991年，当时由Sun公司的James Gosling等人开发了一种名为Oak的语言，...
JavaSE零基础讲义.zip
07-10
首先，Java是一种面向对象的编程语言，由Sun Microsystems（现已被Oracle公司收购）在1995年发布。它的设计目标是“一次编写，到处运行”，这得益于其跨平台的Java虚拟机（JVM）。JavaSE包含了一组丰富的类库，如I/O...
Java 函数接口Predicate【断言】与【谓词逻辑】详解与示例
weixin_42369079的博客
11-06 1979
Predicate函数式接口是Java四个重要的函数式接口（Function、Predicate、Consumer和Supplier）之一。这些接口是函数式编程的基础，Predicate又称断言接口主要用于进行条件判断（断言测试）。Java函数式编程的Stream的过滤器filter()方法的参数就是Predicate的实例。
Predicate函数式接口-在stream流中的使用
qq_40603125的博客
04-29 942
其中，and 方法用于将两个 Predicate 对象的判断结果通过逻辑与操作合并，返回一个新的 Predicate 对象；在上面的代码中，我们使用 Predicate 接口的实现来判断一个数是否为偶数，然后使用 filter 方法将偶数过滤出来，最终使用。上述代码中，我们定义了一个名为 isPositive 的 Predicate 接口的实现，该实现用于判断一个数是否为正数。在上面的代码中，我们定义了一个 validate 方法，该方法接受一个 Predicate 作为规则，然后使用 test。
Predicate接口的理解与应用
m0_58202543的博客
12-13 1550
百度for谓词 Predicate ：用来代替或者展示其客体性质、特征或者客体之间关系的词项。根据《现代汉语》的定义,汉语的体词包括名词,数词,量词；汉语的谓词可以包括一切的例句。百度for客体： 意思是指存在于主体之外的客观事物。也就是客观的描述，描述他是什么，例如有个数，你描述它是大于五的，其实这个数是不是大于5的还不知道。具体这个主体数是啥还得看你用什么进行填充。举例："猫是动物"一句中的"是"就是一个谓词，而"猫"是客体。“3 大于 2"中"大于"是一个谓词。
掌握Java 8中的Predicate函数式接口
末尾卡片和博主交流学习！
11-30 2077
掌握Java 8中的Predicate函数式接口；
JAVA四大接口之Predicate接口
qq_61592687的博客
11-09 1413
上两期博客讲完了前三个接口，现在来说说最后一个接口，Predicate接口，它里面有五个方法，一个静态方法。这个方法也是很简单，只要你理解了前三个，这个也是类似的，话不多说。
【Java函数篇】Java 8 Predicate函数接口的用法详解
分享技术，记录思考和感悟
10-18 2312
自从Java8发布以后，代码里面就多了很多函数式的接口和代码。在流式的编程中，我们经常会用到Predicate和其他函数，在一些开源的代码中也会看到别人定义的Predicate方法。但其实你有没有感觉在写代码的经历中，就很少会定义Predicate方法，都是用在stream流中更多，比如下面这段代码。今天就来学习和分享一下Predicate，彻底了解和掌握Predicate的概念以及用法。
深入理解 Java 的 Predicate 接口组合
最新发布
潜意识Java的博客
06-23 561
在实际开发中，建议将复杂的条件逻辑封装为可复用的 Predicate 组件，并通过组合操作构建更高级的业务规则，从而使代码更加简洁、灵活和可维护。
Java 函数式编程(1 万字）
2301_79083000的博客
10-09 3972
Java 函数式编程是Java8流行的重要支撑
内置函数式接口之 Predicate（谓词型）
张紫娃的博客
07-24 318
test(t);?
2020最新黑马Java SE教程：从入门到精通IDEA版
资源摘要信息: "黑马JavaSE笔记.zip" 是一份关于Java SE（Standard Edition）编程语言的学习材料，由黑马程序员所提供。这份笔记涵盖了从零基础入门到精通Java SE的全过程，适用于对Java语言感兴趣的初学者以及想要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值