JAVA8新特性之函数式接口（三）

LongUnaryOperator：
接受一个参数同为类型long,返回值类型也为long。

   public static void main(String[] args) {
System.out.println("------LongUnaryOperator------");
        LongUnaryOperator longUnaryOperator = (wt)->{
            return (long)wt*100;
        };
        LongUnaryOperator longUnaryOperator1 = (wt)->{
            return (long)wt+10;
        };
        System.out.println("------LongUnaryOperator>>>>"+longUnaryOperator.applyAsLong(1888));
        System.out.println("LongUnaryOperator andThen>>>"+longUnaryOperator.andThen(longUnaryOperator1).applyAsLong(18));
        System.out.println("LongUnaryOperator compose>>>"+longUnaryOperator.compose(longUnaryOperator1).applyAsLong(18));
        System.out.println("LongUnaryOperator identity>>>"+LongUnaryOperator.identity().applyAsLong(18));
        System.out.println("-----LongUnaryOperator------");

    }

输出内容为：

------LongUnaryOperator------
------LongUnaryOperator>>>>188800
LongUnaryOperator andThen>>>1810
LongUnaryOperator compose>>>2800
LongUnaryOperator identity>>>18
LongUnaryOperator------

ObjDoubleConsumer:
接受一个object类型和一个double类型的输入参数，无返回值。

   public static void main(String[] args) {
       System.out.println("-----ObjDoubleConsumer------");
        Map<String,Double> map = new HashMap<String,Double>();
        ObjDoubleConsumer objDoubleConsumer=(wy,wu)->{
            map.put(String.valueOf(wy),wu);
            System.out.println("ObjDoubleConsumer>>>>"+map.get(wy));
        };
        objDoubleConsumer.accept("111111",10.5);
        System.out.println("-----ObjDoubleConsumer------");
    }

输出内容为：

-----ObjDoubleConsumer------
ObjDoubleConsumer>>>>10.5
-----ObjDoubleConsumer------

ObjIntConsumer:
接受一个object类型和一个int类型的输入参数，无返回值。

   public static void main(String[] args) {
       System.out.println("-----ObjIntConsumer------");
        ObjIntConsumer objIntConsumer = (wi,wo)->{
            System.out.println("ObjIntConsumer>>>>"+wi+"||wi class:"+wi.getClass().toString());
            System.out.println("ObjIntConsumer>>>>"+wo+"||wi class"+wo);
        };
        List list = new ArrayList();
        list.add("1");
        objIntConsumer.accept(list,80);
        System.out.println("-----ObjIntConsumer------");
    }

输出内容为：

-----ObjIntConsumer------
ObjIntConsumer>>>>[1]||wi classclass java.util.ArrayList
ObjIntConsumer>>>>80||wi class80
-----ObjIntConsumer------

ObjLongConsumer:
接受一个object类型和一个long类型的输入参数，无返回值。

   public static void main(String[] args) {
       System.out.println("-----ObjLongConsumer------");
        ObjLongConsumer objLongConsumer = (wp,wa)->{
            System.out.println("objLongConsumer>>>>"+wp+"||wi class:"+wp.getClass().toString());
            System.out.println("objLongConsumer>>>>"+wa+"||wi class"+wa);
        };
        Map map1 = new HashMap();
        map1.put("1","1111");
        objLongConsumer.accept(map1,1000);
        System.out.println("-----ObjLongConsumer------");
    }

输出内容为：

-----ObjLongConsumer------
objLongConsumer>>>>{1=1111}||wi class:class java.util.HashMap
objLongConsumer>>>>1000||wi class1000
-----ObjLongConsumer------

Predicate:
接受一个输入参数，返回一个布尔值结果。

  public static void main(String[] args) {
      System.out.println("-----Predicate------");
       Map map2 = new HashMap();
       map2.put("1","1111");
       Predicate predicate=ws->{
           System.out.println("Step 1");
           if(map2.get("1").equals(ws)){
              return false;
           }else{
               return true;
           }
       };
       Predicate predicate1=wd->{
           System.out.println("Step 2");
           if (wd.equals("2")){
               return false;
           }else {
               return true;
           }
       };
       System.out.println("Predicate>>>>"+ predicate.test(2222));
       System.out.println("Predicate negate >>>>"+ predicate.negate().test(2222));
       System.out.println("Predicate and >>>>"+ predicate.and(predicate1).test(222));
       System.out.println("Predicate or >>>>"+ predicate.or(predicate1).test(22));
       System.out.println("-----Predicate------");
   }

输出内容为：

-----Predicate------
Step 1
Predicate>>>>true
Step 1
Predicate negate >>>>false
Step 1
Step 2
Predicate and >>>>true
Step 1
Predicate or >>>>true
-----Predicate------

Supplier:
无参数，返回一个结果。

  public static void main(String[] args) {
            System.out.println("-----Supplier------");
       Supplier supplier = ()->{
           Map map3 = new HashMap();
           map3.put("1","张三");
           return map3;
       };
       System.out.println(" Supplier >>>>"+supplier.get());
       System.out.println("-----Supplier------");
   }

输出内容为：

-----Supplier------
 Supplier >>>>{1=张三}
-----Supplier------

ToDoubleBiFunction:
接受两个输入参数，返回一个double类型结果

  public static void main(String[] args) {
       System.out.println("-----ToDoubleBiFunction------");
       List list1 = new ArrayList();
       list1.add(180.0);
       Map map4 = new HashMap();
       map4.put("a",2000.0);
       ToDoubleBiFunction toDoubleBiFunction=(wf,wg)->{
           return ((double)(((ArrayList)wf).get(0)))+((double)(((HashMap)wg).get("a")));
       };
       System.out.println("ToDoubleBiFunction >>>>>>"+toDoubleBiFunction.applyAsDouble(list1,map4));
       System.out.println("-----ToDoubleBiFunction------");
   }

输出内容为：

-----ToDoubleBiFunction------
ToDoubleBiFunction >>>>>>2180.0
-----ToDoubleBiFunction------

ToIntBiFunction:
接受两个输入参数，返回一个int类型结果。

  public static void main(String[] args) {
      System.out.println("-----ToIntBiFunction------");
       List list2 = new ArrayList();
       list2.add(1800);
       Map map5 = new HashMap();
       map5.put("a",20000);
       ToIntBiFunction toIntBiFunction=(wf,wg)->{
           return ((int)(((ArrayList)wf).get(0)))+((int)(((HashMap)wg).get("a")));
       };
       System.out.println("ToIntBiFunction >>>>>>"+toIntBiFunction.applyAsInt(list2,map5));
       System.out.println("-----ToIntBiFunction------");
   }

输出内容为：

-----ToIntBiFunction------
ToIntBiFunction >>>>>>21800
-----ToIntBiFunction------

ToIntFunction:

  public static void main(String[] args) {
     System.out.println("-----ToIntFunction------");
       Hashtable hashtable = new Hashtable();
       hashtable.put("888",888);
       ToIntFunction toIntFunction = wh->{
           return (int)((Hashtable)(wh)).get("888");
       };
       System.out.println("ToIntFunction >>>>>>"+toIntFunction.applyAsInt(hashtable));
       System.out.println("-----ToIntFunction------");
   }

输出内容为：

-----ToIntFunction------
ToIntFunction >>>>>>888
-----ToIntFunction------

ToLongBiFunction:
接受两个输入参数，返回一个long类型结果。

  public static void main(String[] args) {
       System.out.println("-----ToLongBiFunction------");
       List list3 = new ArrayList();
       list3.add(1800);
       Map map6 = new HashMap();
       map6.put("a",20000);
       ToLongBiFunction longBiFunction = (wj,wk)->{
           long t1 = 0;
           long t2 = 0;
           if (wj instanceof ArrayList){
               t1 = (long)((ArrayList) wj).get(0);
           }else if (wk instanceof HashMap){
               t2 = (long)((HashMap) wk).get("a");
           }
           return t1+t2;
       };
       System.out.println("ToLongBiFunction >>>>>>"+toIntBiFunction.applyAsInt(list3,map6));
       System.out.println("-----ToLongBiFunction------");
   }

输出内容为：

-----ToLongBiFunction------
ToLongBiFunction >>>>>>21800
-----ToLongBiFunction------

ToLongFunction:
接受一个输入参数，返回一个long类型结果。

  public static void main(String[] args) {
      System.out.println("-----ToLongFunction------");
       ToLongFunction toLongFunction = wl->{
           long t1 = 0;
           if (wl instanceof ArrayList){
               t1 = (long)((int)(((ArrayList) wl).get(0)));
           }else if (wl instanceof HashMap){
               t1 = (long)((int)((HashMap) wl).get("a"));
           }
           return t1;
       };
       System.out.println("ToLongFunction list3 >>>>>>"+toLongFunction.applyAsLong(list3));
       System.out.println("ToLongFunction  map6 >>>>>>"+toLongFunction.applyAsLong(map6));
       System.out.println("-----ToLongFunction------");
   }

输出内容为：

-----ToLongFunction------
ToLongFunction list3 >>>>>>1800
ToLongFunction  map6 >>>>>>20000
-----ToLongFunction------

UnaryOperator:
接受一个参数为类型T,返回值类型也为T。

 public static void main(String[] args) {
 System.out.println("-----UnaryOperator------");
      List<String> list4 = new ArrayList<>();
      list4.add("1");
      list4.add("2");
      List<String> list5 = (ArrayList)(UnaryOperator.identity().apply(list4));
      list5.stream().forEach(wx->System.out.println(">>>>>"+wx));
      System.out.println("-----UnaryOperator------");
  }

输出内容为：

-----UnaryOperator------
>>>>>1
>>>>>2
-----UnaryOperator------