Java 8 UnaryOperator 函数接口

在 Java 8 中，UnaryOperator 函数接口和 Function 函数接口十分相似，是 Function 函数接口的扩展，它可以传入一个泛型 T 参数，返回一个泛型 T 结果。

从源码里也可以看到 UnaryOperator 是 Function 接口的子类。

package java.util.function;

@FunctionalInterface
public interface UnaryOperator<T> extends Function<T, T> {

    static <T> UnaryOperator<T> identity() {
        return t -> t;
    }
}

扩展阅读：Java 8 Function 函数接口

1. UnaryOperator

示例：分别使用 UnaryOperator 和 Function 把字符串转换为大写形式。

package com.wdbyte;

import java.util.Locale;
import java.util.function.Function;
import java.util.function.UnaryOperator;

public class Java8UnaryOperator {

    public static void main(String[] args) {
        Function<String, String> upperFun1 = s -> s.toUpperCase();
        UnaryOperator<String> upperFun2 = s -> s.toUpperCase();

        String res1 = upperFun1.apply("wdbyte.com");
        String res2 = upperFun2.apply("wdbyte.com");

        System.out.println(res1);
        System.out.println(res2);
    }
}

输出结果：

WDBYTE.COM
WDBYTE.COM

2. UnaryOperator.identity

不做任何处理，直接返回参数本身，和 Function.identify() 效果一样。

示例：把字符串集合转换成 key 为大写字符串，value 为字符串本身的 Map（使用 identity 方法返回本身）。

package com.wdbyte;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.function.UnaryOperator;
import java.util.stream.Collectors;

public class Java8UnaryOperatorIdentify {

    public static void main(String[] args) {
        Function<String, String> upperFun1 = s -> s.toUpperCase();
        UnaryOperator<String> upperFun2 = s -> s.toUpperCase();

        List<String> list = Arrays.asList("java", "node", "c++", "rust", "www.wdbyte.com");

        Map<String, String> map1 = list.stream()
            .collect(Collectors.toMap(upperFun1::apply, Function.identity()));

        Map<String, String> map2 = list.stream()
            .collect(Collectors.toMap(upperFun2::apply, UnaryOperator.identity()));
      
        Map<String, String> map3 = list.stream()
            .collect(Collectors.toMap(upperFun2::apply, t -> t));

        System.out.println(map1);
        System.out.println(map2);
        System.out.println(map3);
    }
}

输出结果：

{JAVA=java, C++=c++, RUST=rust, NODE=node, WWW.WDBYTE.COM=www.wdbyte.com}
{JAVA=java, C++=c++, RUST=rust, NODE=node, WWW.WDBYTE.COM=www.wdbyte.com}
{JAVA=java, C++=c++, RUST=rust, NODE=node, WWW.WDBYTE.COM=www.wdbyte.com}

3. UnaryOperator 作为参数

示例：使用 UnaryOperator 作为参数，修改 List 集合中每个元素。

package com.wdbyte;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.function.UnaryOperator;
import java.util.stream.Collectors;

public class Java8UnaryOperatorParam {

    public static void main(String[] args) {
        List<String> list = Arrays.asList("java", "node", "c++", "rust", "www.wdbyte.com");
        UnaryOperator<String> upperFun = s -> s.toUpperCase();
        List<String> resultList = map(list, upperFun);
        System.out.println(resultList);

        List<Integer> intList = Arrays.asList(1, 2, 3, 4, 5);
        UnaryOperator<Integer> doubleInt = i -> i * 2;
        List<Integer> integers = map(intList, doubleInt);
        System.out.println(integers);
    }

    public static <T> List<T> map(List<T> list, UnaryOperator<T> unaryOperator) {
        List<T> resultList = new ArrayList<>();
        for (T t : list) {
            resultList.add(unaryOperator.apply(t));
        }
        return resultList;
    }
}

输出结果：

[JAVA, NODE, C++, RUST, WWW.WDBYTE.COM]
[2, 4, 6, 8, 10]

4. UnaryOperator 多个参数

示例：使用 UnaryOperator 作为参数，修改 List 集合中每个元素，先转大写，再截取前三位。

package com.wdbyte;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.UnaryOperator;

public class Java8UnaryOperatorParams {

    public static void main(String[] args) {
        List<String> list = Arrays.asList("java", "node", "c++", "rust", "www.wdbyte.com");
        // 转大写
        UnaryOperator<String> upperFun = s -> s.toUpperCase();
        // 截取 3 位
        UnaryOperator<String> subFun = s -> s.substring(0, 3);
        List<String> resultList = map(list, upperFun, subFun);
        System.out.println(resultList);
    }

    public static <T> List<T> map(List<T> list, UnaryOperator<T>... unaryOperator) {
        List<T> resultList = new ArrayList<>();
        for (T t : list) {
            for (UnaryOperator<T> operator : unaryOperator) {
                t = operator.apply(t);
            }
            resultList.add(t);
        }
        return resultList;
    }
}