Stream流、并发流、常用函数式接口

1.1常用函数式接口：

1.1.1 Predicate函数式接口:

Predicate函数式接口概述：用来封装判断条件。

Predicate函数式接口的抽象方法：boolean test(T t) 执行判断。返回true或false

需求：定义方法,参数是Predicate接口类型，返回值是Boolean类型，在main方法调用定义好的方法判断字符串的长度是否大于5.

import java.util.function.Predicate;

public class PredicateDemo {
    public static void main(String[] args) {
        //使用匿名内部类
        testPredicate(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.length()>5;
            }
        });
        //使用Lambda表达式调用
        testPredicate(str->str.length()>5);
    }
    public static void testPredicate(Predicate<String> predicate){
        boolean b = predicate.test("Hello");
        System.out.println("b="+b);
    }
}

1.1.2 默认方法：and（等价&&）

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

判断一个字符串既要包含大写“H”，又要包含大写“W”：

import java.util.function.Predicate;

/*
    判断一个字符串既要包含大写“H”，又要包含大写“W”
 */
public class PredicateDemo02 {
    public static void main(String[] args) {
        //定义字符串
        String str = "HelloWorld";
        //条件1：判断是否包含"H"
        Predicate<String> one = s -> s.contains("H");
        //条件2：判断是否包含"W"
        Predicate<String> two = s -> s.contains("W");

        boolean test1 = one.test(str);
        boolean test2 = two.test(str);
        if(test1&&test2){
            System.out.println(" 条件成立");
        }

        //判断str是否同时满足条件1和条件2
        boolean test = one.and(two).test(str);
        System.out.println(test);//true
    }
}

1.1.3 默认方法：or

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

import java.util.function.Predicate;

/*
    判断一个字符串包含大写“H”或包含大写“W”
 */
public class PredicateDemo02 {
    public static void main(String[] args) {
        //定义字符串
        String str = "HelloWorld";
        //条件1：判断是否包含"H"
        Predicate<String> one = s -> s.contains("H");
        //条件2：判断是否包含"W"
        Predicate<String> two = s -> s.contains("W");

        //判断str满足条件1或条件2
        boolean test = one.or(two).test(str);
        System.out.println(test);//true
    }
}

1.1.4 默认方法：negate

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

import java.util.function.Predicate;

/*
    判断一个字符串包含大写“H”
 */
public class PredicateDemo02 {
    public static void main(String[] args) {
        //定义字符串
        String str = "helloWorld";
        //条件1：判断是否包含"H"
        Predicate<String> one = s -> s.contains("H");
        boolean test = one.negate().test(str);
        System.out.println(test);//true
    }
}

1.1.5 集合信息筛选：

需求：数组当中有多条“姓名+性别”的信息如下，请通过Predicate 接口的拼装将符合要求的字符串筛选到集合
ArrayList 中，需要同时满足两个条件：
1. 必须为女生；
2. 姓名为4个字。

import java.util.ArrayList;
import java.util.function.Predicate;

public class PredicateDemo05 {
    public static void main(String[] args) {
        String[] array = {"迪丽冷巴,女","凤凰传奇,女","马尔扎哈,男","刘嘉玲,女"};

        //条件1:必须为女生
        Predicate<String> one = str -> str.split(",")[1].equals("女");
        //条件2：姓名必须为4个字
        Predicate<String> two = str ->  str.split(",")[0].length()==4;

       //创建ArrayList集合
        ArrayList<String> list = new ArrayList<>();
        //遍历字符数组
        for (String s : array) {
            //判断s是否同时满足条件
            if(one.and(two).test(s)){
                //将字符串添加到集合中
                list.add(s);
            }
        }

        System.out.println(list);

    }
}

2.1 Function接口：

Function函数式接口的概述：用来将数据从一种类型转换为另一种类型。

Function函数式接口的抽象方法：

R apply（T t）将参数t的数据类型从T类型转换为R类型

需求：将String类型转换为为Integer类型。

public class FunctionDemo01 {
    public static void main(String[] args){
        // 整数字符串
        String str = "123";
        // 将字符串转换为整型数据 123
        // 使用匿名内部类创建Function接口的实现类对象
        Function<String,Integer> f = new Function<String,Integer>(){
            @Override
            public Integer apply(String s) {
                return Integer.parseInt(s);
            }
        };
        // 调用apply方法进行转换
        int num01 = f.apply(str);
        System.out.println(num01);

        // 使用lambda表达式简化
        Function<String,Integer> ff = s -> Integer.parseInt(s);
        int num02 = ff.apply(str);
        System.out.println(num02);

        // 使用方法引用简化lambda表达式
        Function<String,Integer> fff = Integer::parseInt;
        int num03 = fff.apply(str);
        System.out.println(num03);
    }
}

未完，待续......

Stream流、并发流、常用函数式接口

猜你喜欢