java8 function使用

import com.google.common.cache.Weigher;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.ToIntBiFunction;
import java.util.stream.Collectors;

public class LambdaTest {

    @FunctionalInterface
    public interface IFun{
        void fun_noin_noout();
    }

    @FunctionalInterface
    public interface IFun2<I> {
        void fun_in_noout(I i);
    }

    @FunctionalInterface
    public interface IFun3<I, O>{
        O fun_in_out(I i);
    }


    /**
     * 无参，无输出，非静态
     */
    public void f1() {
        System.out.println("f1");
    }

    /**
     * 无参，无输出，静态
     */
    public static void f1_static() {
        System.out.println("f1 static");
    }

    /**
     * 有参，无输出，非静态
     */
    public void f2(int i) {
        System.out.println("f2 i = " + i);
    }

    /**
     * 有参，无输出，静态
     */
    public static void f2_static(int i) {
        System.out.println("f2 static i = " + i);
    }

    /**
     * 有参，有输出，非静态
     */
    public int f3(int a){
        return a;
    }

    /**
     * 有参，有输出，静态
     */
    public static int f3_static(int a) {
        return a;
    }

    /**
     * JS中是怎么用的？f(g())
     * java中是怎么用的？f(()->g())
     */
    public void test() {
        LambdaTest t = new LambdaTest();

        /**
         * 访问对象方法
         * 正常写法：f1();
         * java的写法：如下
         */
        IFun f11 = t::f1;
        f11.fun_noin_noout();

        /**
         * 相当于js里面的
         * f1();
         * 而js里面的f1()又相当于数字 123
         * 其中123为表达式，值为123
         * 计算机的本质就是：表达式
         * 对一个东西进行求值(数学运算)，这个东西姑且叫做表达式，然后得到值
         * 然后就回归到了数学，数学里面的对一个式子求值
         *
         * 使用：
         * js中为直接写方法
         * java中，需要借助一个附属体(方法附属在什么东西上)
         */
        IFun2<LambdaTest> f12 = LambdaTest::f1; //此处不能赋值给IFun，想想为什么，因为f1必须有一个实例对象，也就是需要一个入参
        f12.fun_in_noout(new LambdaTest());

        IFun f1_static = LambdaTest::f1_static;
        f1_static.fun_noin_noout();

        IFun2<Integer> f2 = t::f2;
        f2.fun_in_noout(12);

        IFun2<Integer> f22 = LambdaTest::f2_static;
        f22.fun_in_noout(1222);


        IFun3<Integer, Integer> f3 = t::f3;
        Integer integer = f3.fun_in_out(133333);
        System.out.println("f3    " + integer);

        IFun3<Integer, Integer> f3_static = LambdaTest::f3_static;
        Integer integer1 = f3_static.fun_in_out(133333333);
        System.out.println("f333333   " + integer1);


        /**
         * 访问静态方法
         */
        Consumer<LambdaTest> f_con = LambdaTest::f1;
        f_con.accept(new LambdaTest());

        Function<Integer, Integer> f_fun = LambdaTest::f3_static;
        Integer apply = f_fun.apply(11);
        System.out.println(apply);


    }

    public static void main(String[] args) {
//        int[] a = {1, 2, 3};
//        if (Arrays.stream(a).noneMatch(i -> i == 4)){
//            System.out.println("true");
//        }

        new LambdaTest().test();

        /**
         * sort 里面传入一个方法，比如g
         * js：sort(g(a, b))
         * java: sort((a, b) -> g)
         */

        new ArrayList<Integer>().sort((a, b) -> a.compareTo(b));

        //thread 里面传入一个方法
        new Thread(() -> {});


    }



}