Un: format et description de l'expression Lambda
Le format standard de l'expression Lambda est: (nom du paramètre de type de paramètre) -> {instruction de code}
description:
- La syntaxe entre parenthèses est cohérente avec la liste de paramètres de méthode traditionnelle
- -> est un format grammatical nouvellement introduit, qui représente une action de pointage, indiquant que le paramètre avant la parenthèse est utilisé dans l'instruction de code dans ce qui suit {}
- La syntaxe entre accolades est fondamentalement cohérente avec les exigences du corps de la méthode traditionnelle. Il s'agit en fait d'une réécriture de la seule méthode abstraite de l'interface fonctionnelle.
Deux: format Lambda omis
Lambda met l'accent sur «quoi» plutôt que sur «comment», de sorte que toute information qui peut être dérivée du contexte peut être omise.
Les règles d'omission sont les suivantes:
- Les types de paramètres entre parenthèses peuvent être omis;
- S'il n'y a qu'un seul paramètre entre parenthèses, les parenthèses peuvent être omises;
- S'il existe une et une seule instruction entre accolades, vous pouvez omettre les accolades, le mot-clé return et le point-virgule de l'instruction, qu'il existe ou non une valeur de retour.
1. Pratique Lambda
1.1. Appelez la méthode Collections.sort () pour comparer deux employés par tri personnalisé (d'abord par rapport d'âge, le même rapport âge par nom), en utilisant Lambda comme paramètre pour transmettre le
code de référence comme suit:
package com.demo.lambda.day04;
public class Employee {
private String name;
private int age;
/**
* 有参构造
* @param name
* @param age
*/
public Employee(String name, int age) {
this.name = name;
this.age = age;
}
public String toString() {
return "Employee{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
package com.demo.lambda.day04;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
/**
* 调用Collections.sort()方法，
* 通过定制排序比较两个Employee(先按年龄比，年龄相同按照姓名比)，
* 使用Lambda作为参数传递
*/
public class lambdaCompareAge {
public static void main(String[] args) {
List<Employee> list = Arrays.asList(new Employee("小红", 13),
new Employee("小明", 11),
new Employee("小张", 12),
new Employee("小李", 11));
Collections.sort(list,(e1,e2)->{
int num1 = Integer.compare(e1.getAge(), e2.getAge());
int num2 = num1==0?e1.getName().compareTo(e2.getName()):num1;
return num2;
});
//遍历循环输出
for(Employee e:list){
System.out.println(e);
}
}
}
1.2. Déclarez l'interface fonctionnelle, déclarez la méthode abstraite publique String getValue (String str)
dans l'interface pour déclarer la classe Test02, et écrivez la méthode dans la classe pour utiliser l'interface comme paramètre, convertissez une chaîne en majuscules et utilisez
un autre caractère comme valeur de retour de la méthode Les éléments situés entre la 2ème et la 4ème position d'index de la chaîne sont interceptés. Le
code de référence est le suivant:
package com.demo.lambda.day04;
@FunctionalInterface
public interface StringInter {
public String getValue(String str);
}
package com.demo.lambda.day04;
public class StringLambdaTest {
public static void main(String[] args) {
String str = "HelloWorld";
//需求1：将一个字符串转成大写
String s1 = fun(str, s->s.toUpperCase());
System.out.println(s1);
//需求2：将一个字符串的第2个和第4个索引位置进行截取子串
String s2 = fun(str, s->s.substring(2, 5));
System.out.println(s2);
}
//用于处理字符串
public static String fun(String s,StringInter i){
return i.getValue(s);
}
}
1.4. String str = "Zhao Liying, 28";
intercepter la partie d'âge numérique de la chaîne pour obtenir une chaîne;
convertir la chaîne de l'étape précédente en un nombre de type int;
ajouter 100 au nombre int de l'étape précédente pour obtenir le résultat entier nombre.
Le code de référence est le suivant:
package com.demo.lambda.day04;
import org.junit.Test;
import java.util.function.Function;
public class Demo4 {
@Test
public void test04() {
String str = "赵丽颖,28";
int result = fun(s->s.split(",")[1],
s->Integer.parseInt(s),
n -> n += 100, str);
System.out.println(result);
}
public int fun(Function<String,String> one,
Function<String,Integer> two, Function<Integer,Integer> three, String s){
return one.andThen(two).andThen(three).apply(s);
}
}
1.5 Veuillez imprimer les informations au format "Nom: XX. Sexe: XX.".
Les
codes de référence "Dilraba, femme", "Gulinaza, femme", "Nurhachi, homme" sont les suivants:
package com.demo.lambda.day04;
import org.junit.Test;
import java.util.function.Consumer;
public class Demo5 {
@Test
public void test05() {
String[] arr = {"迪丽热巴,女","古力娜扎,女","努尔哈赤,男"};
printInfo(s->System.out.print("姓名:"+s.split(",")[0]),
s->System.out.println("。性别："+s.split(",")[1]), arr);
}
public void printInfo(Consumer<String> one, Consumer<String> two, String[] arr){
for(String s:arr){
one.andThen(two).accept(s);
}
}
}
==========================
输出结果：
姓名:迪丽热巴。性别：女
姓名:古力娜扎。性别：女
姓名:努尔哈赤。性别：男1.6. Le tableau contient plusieurs informations "nom + sexe" ("Dilraba, femme", "Guli Nazha, femme", "Nurhachi, homme", "Zhao Liying, femme")
. Veuillez utiliser l'interface Predicate. filtre les chaînes qui répondent aux exigences dans la collection ArrayList, et deux conditions doivent être remplies en même temps:
1) Doit être une fille; 2) Le nom est composé de 4 caractères Le
code de référence est le suivant:
package com.demo.lambda.day04;
import org.junit.Test;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;
public class Demo6 {
@Test
public void test06() {
String[] ary = {"迪丽热巴,女","古力娜扎,女","努尔哈赤,男","赵丽颖,女"};
List<String> list = filter(s->s.split(",")[1].equals("女"),
s->s.split(",")[0].length()==4, ary);
System.out.println(list);
}
public List<String> filter(Predicate<String> one, Predicate<String> two, String[] ary){
List<String> list = new ArrayList<String>();
for(String p:ary){
if(one.and(two).test(p)){
list.add(p.split(",")[0]);
}
}
return list;
}
}
输出结果：
[迪丽热巴, 古力娜扎]