Funciones relacionadas con jdk8.0 (1)

Funciones relacionadas con JDK8.0

1. La nueva sintaxis de la interfaz en JDK8.0

JDK8.0, los métodos estáticos se pueden definir en la interfaz, con la implementación como parte del método.
- Sintaxis: nombre de método de tipo de valor de retorno estático público (lista de parámetros) {// parte de implementación}
JDK8.0, los métodos no abstractos con implementaciones predeterminadas se pueden definir en la interfaz
- Sintaxis: nombre del método del tipo de valor de retorno predeterminado público (lista de parámetros) {// implementación del método}

En segundo lugar, la sintaxis relevante de las expresiones Lambda

Las expresiones Lambda implementan interfaces y crean objetos (escritura simplificada de clases internas anónimas)
Las expresiones Lambda introducen un nuevo símbolo y elemento de sintaxis en el lenguaje Java: "->", este operador se llama operador Lambda u operador de flecha, este operador divide la expresión Lambda en dos partes:
- Izquierda: especifique los parámetros requeridos por la expresión Lambda
- Derecha: especifique la parte de la función de ejecución de la expresión Lambda
Formato de sintaxis 1: sin parámetros, sin valor de retorno

Nombre de la interfaz nombre de referencia = () -> {// Parte de la función de ejecución};

Caso:
```
public class Test {
    public static void main(String[] args) {
        IA ia = ()->{
            System.out.println("m1方法....");
        };
        ia.m1();
    }
}
interface IA{
    void m1();
｝
```
Nota:
- En la interfaz implementada por la expresión Lambda, solo se debe definir un método abstracto en la interfaz;
- Si el cuerpo de implementación de la expresión Lambda tiene solo una declaración, {} se puede omitir y no se recomienda.

Sintaxis 2: con parámetros, sin valor de retorno

Referencia de nombre de interfaz = (tipo de datos nombre de variable) -> {// cuerpo de implementación ...};

Caso 1: un parámetro

public class Test {
    public static void main(String[] args) {
       IA ia = (int n)->{
           if(n%2==0){
               System.out.println(n+"是偶数....");
           }else{
               System.out.println(n+"是奇数....");
           }
       };
       ia.m1(6);
    }
}
interface IA{
    void m1(int n);
}

Caso 2: múltiples parámetros

public class Test {
    public static void main(String[] args) {
        IA ia = (int a,double b)-> {
            System.out.println("a="+a+",b="+b);
        };
        ia.m1(3,9.8);
    }
}
interface IA{
    void m1(int n,double d);
}

Nota: El tipo de datos en la expresión Lambda se puede omitir porque el compilador puede realizar inferencias de tipos.

Sintaxis 3: con valor de retorno

Nombre de la interfaz nombre de referencia = (lista de parámetros) -> {declaración de retorno;}
```
public class Test {
    public static void main(String[] args) {
        IA ia = (a)->{
            if(a<5){
                a=a+1;
            }
            return a;
        };
        int r=ia.m1(3);
        System.out.println("r="+r);
    }
}
interface IA{
    int m1(int a);
}
```
Nota: Si solo hay una declaración de retorno en la expresión Lambda, se puede escribir como

Referencia de nombre de interfaz = (lista de parámetros formales) -> expresión; no recomendado.

Tres, la aplicación práctica de expresiones Lambda

Aplicación práctica 1: use expresiones Lambda para implementar la interfaz Ruannble

public class Test {
    public static void main(String[] args) {
       Runnable r = ()->{
           for(int i=0;i<10;i++){
               System.out.println("+++++++++++++++"+i);
           }
       };
       new Thread(r).start();
    }
}

Aplicación práctica 2: Utilizar expresiones Lambda para completar la realización de Consumer, recibir datos para completar la operación correspondiente

public class Test {
    public static void main(String[] args) {
        Consumer<String> c = (String s)->{
            System.out.println(s);
        };
        c.accept("百知威武....");
    }
}

Aplicación práctica 3: use la expresión Lambda para completar, enumerar el recorrido de la colección

Utilice la clase interna anónima para completar:

 ```
 List<String> list=Arrays.asList("胡老八","李四,"张三","胡明");
 list.forEach(new Consumer<String>() {
 		public void accept(String s) {
      	if(s.contains("胡")){
          	System.out.println(s);
           }
      }
 });

Utilice la expresión Lambda para completar:

List<String> list=Arrays.asList("胡老八","李四,"张三","胡明");
list.forEach((s)-> {
	if (s.contains("胡")) {
		System.out.println(s);
	}
});

只是List集合打印遍历输出： list.for((s)-> System.out.println(s))

Ejercicio: almacene varios objetos de estudiantes en la colección ArrayList:
- Filtrar todos los chicos de la colección de estudiantes
- Filtrar todos los estudiantes reprobados en la colección de estudiantes
- Filtrar todos los estudiantes varones reprobados en la colección de estudiantes
- Filtra a todos los chicos de apellido Liu que fallaron en el grupo de estudiantes.

Ejercicio 2: Llame al método Collections.sort (), compare dos Srudents por clasificación personalizada (primero compare por edad y luego ordene por grado), utilizando la expresión Lambda como parámetro para aprobar.

public class Test {
    public static void main(String[] args) {
        ArrayList<Student> list = new ArrayList();

        list.add(new Student("张三",23,88.0));
        list.add(new Student("李四",26,98.0));
        list.add(new Student("胡八一",25,78.0));
        list.add(new Student("胡八一",25,88.0));

        Collections.sort(list,(s1,s2)->{
            if(s1.getAge()>s2.getAge()){
                return 1;
            }else if(s1.getAge()<s2.getAge()){
                return -1;
            }else{
                return Double.compare(s1.getScore(),s2.getScore());
            }
        });
        list.forEach((s)-> System.out.println(s));
    }
}

Cuatro, interfaz funcional (las expresiones Lambda necesitan el soporte de la interfaz funcional)

Significado: una interfaz con un solo método abstracto en la interfaz se denomina interfaz funcional.

Interfaz funcional personalizada: puede utilizar la anotación @FunctionalInterface para detectar si la interfaz es una interfaz funcional.

@FunctionalInterface
interface IA{
    int m1(int a);
}

Nota: Debe haber solo un método abstracto en la interfaz anotado con @FunctionalInterface. Carcasa de interfaz funcional personalizada:

public class Test {
    public static void main(String[] args) {
        int r = optional(5,(m)->{return m*m;});
        System.out.println("r="+r);
    }
    public static Integer optional(int n,MyFuntion f){
        return f.getValue(n);
    }
}
//对一个整数进行计算操作，将计算的结果作为返回值返回
interface MyFuntion{
    Integer getValue(int n);
}

Cuatro interfaces funcionales centrales integradas en Java8.0

Interfaz de consumidor: consumidor
- void accept (T t); -> El parámetro es de tipo T, y el valor de retorno es de tipo void
Interfaz de suministro: Proveedor
- T get (); -> El parámetro no es ningún parámetro y el valor de retorno es de tipo T
Interfaz funcional: Función <T, R>
- R aplicar (T t); -> El tipo de parámetro es tipo T y el valor de retorno es tipo R

Interfaz de afirmación: predicado

prueba booleana (T t); -> El parámetro es de tipo T, y el valor de retorno es de tipo booleano

Caso 1: Interfaz del consumidor:

public class TestFirst {
    public static void main(String[] args) {
        happy(20000.0,(s)-> System.out.println("拿着"+s+"元去消费...."));
    }
    public static void happy(double money, Consumer<Double> c){
        c.accept(money);
    }
}

Caso 2: Interfaz de tipo de suministro

public class TestFirst {
    public static void main(String[] args) {
        happy(20000.0,(s)-> System.out.println("拿着"+s+"元去消费...."));
        String str=getString(10,()->{
            String s = "anhjshfjshsairiweriwir89863lkkqljrkql";
            java.util.Random rd = new java.util.Random();
            int n=rd.nextInt(s.length());
            return s.charAt(n);
        });
        System.out.println(str);
    }
    public static String getString(int num, Supplier<Character> s){
        String result=null;
        for(int i=0;i<num;i++){
            String str=s.get()+"";
            result +=str;
        }
        return result;
    }
 }

Caso 3: Interfaz funcional

 public class TestFirst {
    public static void main(String[] args) {
        String r=changString("helloworld",(s)->s.toUpperCase());
        System.out.println(r);
        System.out.println(changString("helloworld",(s)->s.substring(1,4)));
    }
    public static String changString(String s, Function<String,String> f){
        return f.apply(s);
    }
}

Caso 4: Interfaz de afirmación

public class TestFirst {
    public static void main(String[] args) {
        List<String> list= Arrays.asList("zhangsan","lisi","wangwu","lily","tom");
        List<String> asList=filterString(list,(s)->s.length()>4);
        for(String s:asList){
            System.out.println(s);
        }
    }
    //将集合中所有的数据元素，根据条件进行过滤
    public static List<String> filterString(List<String> list,Predicate<String> p){
        List<String> asList=new ArrayList<>();
        for(String s:list){
            if(p.test(s)){
                asList.add(s);
            }
        }
        return asList;
    }
}

Otras interfaces funcionales: