java 看清lambda

函数lmabda的使用：
* 1、接口函数组成完整的方法。interface 类接口名称{ public void或（public 返回值类型参数） 接口方法名称(有参数/无参数);}；
* 完全式：类接口名称  类引用名var = (有参数/无参数) ->{表达式}；
*
* 2、引用静态方法：
* 1、引用接口函数；2、引用静态类的方法作为lmabda函数的表达式；3、如果接口函数有参数则静态类的参数要与接口函数的参数一致；
* 完全式：类接口名称  类引用名var = 静态类::静态方法名称；
*
* 3、引用实例方法：
* 1、引用接口函数；2、引用实例类的方法作为lmabda函数的表达式；3、如果接口函数有参数则实例类的参数要与接口函数的参数一致；
* 完全式：
* 1、类名称  类引用名var(即对象名） = new 类名称();
* 2、类接口名称  类引用名var = 实例类（即对象名)::实例方法名称；
*
* 4、引用带有泛型的方法
* 1、引用泛型接口函数；interface 类接口名称<T> { public void或（public 返回值类型 T） 接口方法名称(有参数/无参数);}；
* 2、引用静态类的泛型方法作为lmabda函数的表达式，如果泛型接口函数有参数则静态类的参数要与泛型接口函数的参数一致；
* 类接口名称<T> ，<T> 不可以不用写。
* 完全式：类接口名称<T>  类引用名var = 静态类::<T>静态方法名称；
* 3、引用实例类的泛型方法作为lmabda函数的表达式，类实例化后，反类型接口必须指定泛型的类型，否则报错。
* 完全式：类名称  类引用名var(即对象名） = new 类名称();
*        类接口名称<T>  类引用名var = 实例类（即对象名)::<T>实例方法名称；
*
* 5、引用无参数构造方法
* 1、引用接口函数；
*   interface 类接口名称{ 类名称 类接口的方法名称();}；
*
* 2、创建类，创建类构造函数
* 完全式： 类接口名称  类引用名var_old = 类名称::new ;
*         类名称    类引用名var_new = 类引用名var_old.类接口的方法名称();(注意：方法的返回类型是类）
* 3、注意如果类中有多个构造函数，则看接口函数是否有参数，则对应参数的构造函数
*
* 6、引用数组构造方法
* 1、创建泛型接口函数，泛型参数T；也可以指定类型，用泛型指定类型，通用性强。
* interface 类接口名称<T> { T 类接口方法名称(int n);}；
* 类接口名称<类数组名称[]>  类引用名var = 类名称[]::new；
* 类名称  类引用名var_array[] = 类引用名var.类接口方法名称(int n); //n表示创建构造函数实例化的个数。

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashSet;
import java.util.List;
//无参数的Lambda表达式接口
interface  VoidInterface{
    void print();
}

//有参数的Lambda表达式接口
interface  ParaIterface{
    void print(int i);
}

//不定长参数（Object... values）的Lambda表达式接口
interface  RandomLengthParaIterface{
    void print(Object... values);
}

//使用lambda的静态方法
//1、先创建lmabda的接口，2、再创建静态类，做lambda的表达式
interface  NumInterface{
    int add(int x, int y);}



//使用lambda的实例方法
//1、先创建lmabda的接口，2、再创建实例类，做lambda的表达式
interface  Dateinterface{
    String dateformat(Date date);
};
class Datainstance{
    public String dateformat(Date date){
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

        return sdf.format(date);
    }
}


//使用lambda的泛型静态类方法
//创建泛型接口
interface Paradigminterface<T>{
    int paradigm(T[] t);
}

//创建静态类泛型方法
class Paradigm<T> {
    static public <T> int paradigm(T[] t) {
        int arraylength = t.length;
        //设置set集合 去重复。
        HashSet<T> set = new HashSet<T>();
        for (int i = 0; i < arraylength; i++) {
            set.add(t[i]);
        }

        return t.length - set.size(); //返回去重后的长度
    }
}

//实例化泛型方法
class ParadigmInstance{
   public <T> T paradigm(T[] t){
       int arraylength = t.length;
       //set集合去重复。
       HashSet<T> set = new HashSet();
       for(int i=0;i<arraylength;i++){
           set.add(t[i]);
       }

       //强制转换
       T distinct ;
       distinct = (T) Integer.valueOf(t.length-set.size());
       return distinct;

   }
}


//引用构造函数的Lambda表达式
interface  ConstructorInterface{
    Constructor constructor();

};
//创建带有构造函数的类
class Constructor{
    public Constructor(){
        System.out.println("无参构造函数");
    }
    public Constructor(String str){
        System.out.println("有参构造函数");
    }
    public String constructor(){
        System.out.println("引用构造函数");
        return "构造函数";
    }
}

//引用数组构造方法的Lambda表达式
interface  ArrayConstructorInterface<T>{
    T arrayconstructor(int n);

};
//创建空类
class ArrayConstructor{
    void ar(){
        System.out.println("调用方法");
    }


}




class  Num{
    static int v = 10;
    public static int numsadd(int x, int y){
        //在类里可以引用静态类成员,局部变量
            Num.v =9;
            int a = 1;
        if(v==9){
            Num.v =20;
            a = 2;
            System.out.println(a);
        }
        return x+y;
    }
}





//有参数返回型的Lambda表达式接口
interface  ParaReturnInterface{
    int add(int x, int y);

}

public class Lmabda_1 {
    int ll = 10;

    void test_1(){
        int value1 = 0;
        VoidInterface print_2 = ()-> {
//            value1 =1; //lambda不能改变局部变量，否则报错报错
            System.out.println("引用局部变量 "+value1);


            this.ll =9;//改变类变量值
            System.out.println("改变并引用类变量 "+this.ll);
        };
        print_2.print();
    }
    public static void main(String[] args) {
        //无参数的Lambda表达式创建及运行
        VoidInterface print = () -> System.out.println("Hello World");
        print.print();

        //lambada 不能在main中改变局部变量和类成员,否则报错，但可以引用其值。
        int value1 = 0;
        VoidInterface print_1 = ()-> {
//            value1 =1;//改变则报错
            System.out.println("引用局部变量 "+value1);
        };
//        VoidInterface print_1 = ()-> {
//            ll = 9;
//            System.out.println("引用类成员 "+ll);
//        };


        //有参数的Lambda表达式创建及运行
        ParaIterface print1 = (i) -> System.out.println("Hello World "+i);
        print1.print(520);

        //不定长参数（Object... values）的Lambda表达式创建及运行
        RandomLengthParaIterface print2 = (Object... values) -> {
            for (Object value : values) {
                if (value instanceof List){
                    System.out.println(value.toString());
                }else{
                    System.out.println(value);
                }
            }
        };
        print2.print("1,3,4,5",3,"45");

        //有参数返回型的Lambda表达式创建及运行
        ParaReturnInterface print3 = (x,y) -> x+y;
        System.out.println(print3.add(1,2));




        //使用lambda的静态方法
        NumInterface print4 = Num::numsadd;
        System.out.println("静态类方法："+print4.add(5,2));


        //使用lambda的实例方法
        Datainstance instancedate = new Datainstance();
        Dateinterface print5 = instancedate::dateformat;
        System.out.println("实例类方法："+print5.dateformat(new Date()));


        Integer a[] = {1,2,3,3,5,6,6,8,9,9,1,1,10,10};
        String[] strName={"孙悟空","猪八戒","沙和尚","小白龙","大白龙","白骨精","唐三藏","白骨精","孙悟空"};
        Paradigminterface<String> print6 = Paradigm::<String>paradigm; //可以不指定类型
        System.out.println("泛型静态类方法：重复元素有："+print6.paradigm(strName));
        Paradigminterface <Integer> print7 = Paradigm::paradigm;
        System.out.println("泛型静态类方法：重复元素有："+print7.paradigm(a));

        //使用lambda的泛型实例方法

        ParadigmInstance paradigmInstance = new ParadigmInstance();
        // 类接口必须指定泛型的类型，因实例化对象::实例方法 作为表达式，必须指定泛型的类型，否则报错
        Paradigminterface<Integer>  print8 = paradigmInstance::paradigm;
        System.out.println("泛型实例类方法：重复元素有："+print8.paradigm(a));


        //引用构造函数的Lambda表达式
        ConstructorInterface print9 = Constructor::new;
        Constructor p_constructor = print9.constructor();


        //引用数组构造方法的Lambda表达式
        ArrayConstructorInterface<ArrayConstructor[]> arrayClass = ArrayConstructor[]::new;
        ArrayConstructor[] array= arrayClass.arrayconstructor(3);
        array[0] = new ArrayConstructor(){
            //虽然不会报错，但无法调用
            public void  cons(){
                System.out.println("构造函数");
            }
        };
        array[1] = new ArrayConstructor();
        array[2] = new ArrayConstructor();
        //如果调用或给array[3]赋值，则会出现下标异常报错
//        array[3] = new ArrayConstructor();
        array[0].ar();

    }
}