Java 8 一元运算符UnaryOperator and BinaryOperator Example

最新推荐文章于 2025-06-22 14:50:44 发布

原创最新推荐文章于 2025-06-22 14:50:44 发布 · 4.2k 阅读

4 ·

CC 4.0 BY-SA版权

文章标签：

#jdk8

jdk8 专栏收录该内容

1 篇文章

订阅专栏

本文详细介绍了Java8中UnaryOperator与BinaryOperator的功能及用法，包括它们如何作为lambda表达式工作，以及BinaryOperator的maxBy和minBy方法的具体应用案例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Java 8介绍了UnaryOperator和BinaryOperator可以用于指定作为lambda表达式。 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)，实例会是UnaryOperator的实例。例子如下
UnaryOperatorDemo.java

package com.concretepage.util.stream;
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;
    }
}

Find the output.

BinaryOperator

BinaryOperator

java.util.function.BinaryOperator是函数式接口，并且是lambda表达式。BinaryOperator继承自 java.util.function.BiFunction。接收两个参数返回一个相同类型的值。例子如下
BinaryOperatorDemo.java

package com.concretepage.util.stream;
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;
    }
}

Find the output.

X-A
Y-B
Z-C

BinaryOperator.maxBy and BinaryOperator.minBy

BinaryOperator.maxBy accepts a Compotator and returns BinaryOperator which will return maximum between two elements. In the same way, BinaryOperator.minBy is used to get minimum between two elements.
MaxByMinBy.java

package com.concretepage.util;
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()));
    }
}

Find the Student class used in Example.
Student.java

package com.concretepage.util;
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;
    }
}

Find the output.

 ---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