【Java 8 新特性】Java 8 UnaryOperator和BinaryOperator示例

Java 8引入了可以分配为lambda表达式的UnaryOperator和BinaryOperator。

UnaryOperator和BinaryOperator是功能接口。

UnaryOperator扩展Function和BinaryOperator扩展BiFunction，因此它们接受参数。

UnaryOperator接受一个操作数，并返回与操作数相同类型的值。

BinaryOperator接受两个相同类型的操作数，并返回与操作数相同类型的结果。

UnaryOperator

java.util.function.UnaryOperator是一个Java 8功能接口，它扩展了java.util.function.Function。

UnaryOperator用于处理单个操作数。

它返回与操作数相同的类型。

UnaryOperator可用作lambda表达式作为参数传递。

在定义UnaryOperator时，我们需要定义Function.apply(Object)，其中Function将是UnaryOperator的实例。

查找示例。

UnaryOperatorDemo.java

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.UnaryOperator;
public class UnaryOperatorDemo {
    public static void main(String[] args) {
       List<Integer> list = Arrays.asList(10,20,30,40,50);
       UnaryOperator<Integer> unaryOpt = i->i*i; 
       unaryOperatorFun(unaryOpt, list).forEach(x->System.out.println(x));       
    }
    private static List<Integer> unaryOperatorFun(UnaryOperator<Integer> unaryOpt, List<Integer> list){
       List<Integer> uniList = new ArrayList<>();
       list.forEach(i->uniList.add(unaryOpt.apply(i))); 
       return uniList;
    }
}

输出

100
400
900
1600
2500 

BinaryOperator

java.util.function.BinaryOperator是一个功能接口，可以将其分配为lambda表达式。

BinaryOperator扩展了java.util.function.BiFunction。

它接受两个相同类型的操作数并对其进行处理，然后返回与操作数相同类型的结果。

BinaryOperatorDemo.java

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.BinaryOperator;
public class BinaryOperatorDemo {
    public static void main(String[] args) {
       Map<String,String> map = new HashMap<>();
       map.put("X", "A");
       map.put("Y", "B");
       map.put("Z", "C");
       BinaryOperator<String> binaryOpt = (s1,s2)-> s1+"-"+s2; 
       binaryOperatorFun(binaryOpt, map).forEach(x->System.out.println(x));       
    }
    private static List<String> binaryOperatorFun(BinaryOperator<String> binaryOpt, Map<String,String> map){
       List<String> biList = new ArrayList<>();
       map.forEach((s1,s2)->biList.add(binaryOpt.apply(s1,s2))); 
       return biList;
    }
} 

输出

X-A
Y-B
Z-C 

BinaryOperator.maxBy和BinaryOperator.minBy

BinaryOperator.maxBy接受Compotator并返回BinaryOperator，它将返回两个元素之间的最大值。

同样，BinaryOperator.minBy用于获取两个元素之间的最小值。

MaxByMinBy.java

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.function.BinaryOperator;
import java.util.stream.Collectors;
public class MaxByMinBy {
    public static void main(String[] args) {
        Student s1 = new Student("Shyam", 22,"A");
        Student s2 = new Student("Ram",23,"A");
        Student s3 = new Student("Mohan",22,"B");
        Student s4 = new Student("Ramesh",21,"B");
        List<Student> list = Arrays.asList(s1,s2,s3,s4);
        Comparator<Student> ageComparator = Comparator.comparing(Student::getAge); 
        //Using BinaryOperator.maxBy        
        System.out.println("---BinaryOperator.maxBy---");
        Map<String, Optional<Student>> eldestByClass = list.stream().collect(Collectors.groupingBy(Student::getClassName, 
                Collectors.reducing(BinaryOperator.maxBy(ageComparator))));
        eldestByClass.forEach((k,v)->System.out.println("Class:"+k+" Age:"+
                ((Optional<Student>)v).get().getAge()+" Name:"+((Optional<Student>)v).get().getName()));
        
        //Using BinaryOperator.minBy        
        System.out.println("---BinaryOperator.minBy---");
        Map<String, Optional<Student>> youngestByClass = list.stream().collect(Collectors.groupingBy(Student::getClassName, 
                Collectors.reducing(BinaryOperator.minBy(ageComparator))));
        youngestByClass.forEach((k,v)->System.out.println("Class:"+k+" Age:"+
                ((Optional<Student>)v).get().getAge()+" Name:"+((Optional<Student>)v).get().getName()));
    }
} 

Student.java

public class Student {
    private String name;
    private Integer age;
    private String className;
    public Student(String name,Integer age, String className){
        this.name=name;
        this.age=age;
        this.className = className;
    }
    public String getName() {
        return name;
    }
    public Integer getAge() {
        return age;
    }
    public String getClassName() {
        return className;
    }
}  

输出

 ---BinaryOperator.maxBy---
Class:A Age:23 Name:Ram
Class:B Age:22 Name:Mohan
---BinaryOperator.minBy---
Class:A Age:22 Name:Shyam
Class:B Age:21 Name:Ramesh 

参考文献

【1】Java 8 UnaryOperator and BinaryOperator Example