本文共 5315 字，大约阅读时间需要 17 分钟。

Java-8-UnaryOperator

UnaryOperator extends Function<T, T>

源码:

@FunctionalInterfacepublic interface UnaryOperator
   
     extends Function
    
      {        static 
     
       UnaryOperator
      
        identity() {        return t -> t;    }}
      
     
    
   

这个接口继承Function接口，Funtion接口，定义了一个apply的抽象类，接收一个泛型T对象，并且返回泛型R对象

这个接口，只接收一个泛型参数T，集成Function接口，也就是说，传入泛型T类型的参数，调用apply后，返回也T类型的参数；这个接口定义了一个静态方法，返回泛型对象的本身

简单例子

public class M1 {    public static void main(String[] args) {        UnaryOperator
   
     u1 = integer ->                integer + 100;        System.out.println(u1.apply(100));        System.out.println("-----------");        List
    
      strings = Arrays.asList(                "asas",                "ddd",                "csd"        );        UnaryOperator
     
       unaryOperator = s ->                s;        for (String s : strings) {            System.out.println(unaryOperator.apply(s));        }        System.out.println("-----------");        List
      
        list = Arrays.asList(10,20,30,40,50);        UnaryOperator
       
         unaryOperator2 = integer -> integer*integer;        unaryOperatorFun(unaryOperator2,list)                .forEach(System.out::println);            }    private static List
        
          unaryOperatorFun(UnaryOperator
         
           unaryOpt, List
          
            list){ List
           
             uniList = new ArrayList<>(); list.forEach(i->uniList.add(unaryOpt.apply(i))); return uniList; }}
           
          
         
        
       
      
     
    
   

DoubleUnaryOperator IntUnaryOperator LongUnaryOperator

public class M2{    public static void main(String[] args) {        DoubleUnaryOperator o1 = d ->                d + d * 12.36;        System.out.println(o1.applyAsDouble(12.58));        System.out.println("-------------------------");        IntUnaryOperator o2 = i ->                (int) (i * 100 + 236.22);        System.out.println(o2.applyAsInt(121));        System.out.println("-------------------------");        LongUnaryOperator longUnaryOperator = l ->                (long) (l * 12.36 + 96.33);        System.out.println(longUnaryOperator.applyAsLong(1212));    }}

BinaryOperator extends BiFunction<T,T,T>

源码:

@FunctionalInterfacepublic interface BinaryOperator
   
     extends BiFunction
    
      {       public static 
     
       BinaryOperator
      
        minBy(Comparator
        comparator) {        Objects.requireNonNull(comparator);        return (a, b) -> comparator.compare(a, b) <= 0 ? a : b;    }        public static 
       
         BinaryOperator
        
          maxBy(Comparator
          comparator) { Objects.requireNonNull(comparator); return (a, b) -> comparator.compare(a, b) >= 0 ? a : b; }}
        
       
      
     
    
   

BinaryOperator 二元操作符， 传入的两个参数的类型和返回类型相同,继承BiFunction

public class M1 {    public static void main(String[] args) {        BinaryOperator
   
     b1 = (i1,i2) -> i1 + i2;        System.out.println(compute_1(100,150,b1));        System.out.println("-----------------");        System.out.println(compute_1(102,145,(x,y) -> x * y));        System.out.println("-----------------");        BinaryOperator
    
      b2 = (s1,s2) -> s1.length() + "---" + s2.length();        System.out.println(b2.apply("abc","123456"));    }    public static Integer compute_1(int a1,int a2,BinaryOperator
     
       binaryOperator){        return binaryOperator.apply(a1,a2);    }}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;    }}public class M2 {    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
      
        list = Arrays.asList(s1,s2,s3,s4);        Comparator
       
         comparator = Comparator.comparing(Student::getAge);        //Using BinaryOperator.maxBy        System.out.println("---BinaryOperator.maxBy---");        Map
        
         > map = list.stream() .collect(Collectors.groupingBy(Student::getClassName, Collectors.reducing(BinaryOperator.maxBy(comparator)))); map.forEach((k,v)->System.out.println("Class:"+k+" Age:"+ ((Optional
         
          )v).get().getAge()+" Name:"+((Optional
          
           )v).get().getName())); //---BinaryOperator.maxBy--- //Class:A Age:23 Name:Ram //Class:B Age:22 Name:Mohan System.out.println(""); }}
          
         
        
       
      
     
    
   

DoubleBinaryOperator IntBinaryOperator LongBinaryOperator

public class M3 {    public static void main(String[] args) {        DoubleBinaryOperator doubleBinaryOperator = (d1,d2) ->                d1*12.36 + d2 * 23.369;        System.out.println(doubleBinaryOperator.applyAsDouble(10.25,236.69));        System.out.println("-----------------");        IntBinaryOperator intBinaryOperator = (i1,i2) ->                i1 + i2;        System.out.println(intBinaryOperator.applyAsInt(100,3000));        System.out.println("-----------------");        LongBinaryOperator longBinaryOperator = (l1,l2) ->                l1 * l2;        System.out.println(longBinaryOperator.applyAsLong(125L,20L));    }}

转载地址：http://iccqb.baihongyu.com/