java8的Lambda详解

短命女 2022-03-17 00:50 146阅读 0赞

**(jdk1.8)Lambda** 表达式实质是一个可以实现某一接口的匿名内部类的中的方法   
Lambda表达式组成部分

括号包起来的参数 (若参数仅有一个 可省略括号)  
一个箭头 既 (-> 操作符)  
方法体，可以是单个语句，也可以是语句块 (若是单个语句 则可以直接写出结尾不需要; 结束，若为语句块则两边需加入花括号，每局结尾以; 结束)

参数可以写类型，也可以不写，   
方法可以有返回，也可以无返回,如果是一条语句，结果可以作为默认为返回值，   
如果有多个语句，需要加上return

# 以下例子可直接copy测试用 #

**简单的：**

# **1.** #

// 1. 不需要参数,返回值为 5    
() -> 5    
    
// 2. 接收一个参数(数字类型),返回其2倍的值    
x -> 2 \* x    
    
// 3. 接受2个参数(数字),并返回他们的差值    
(x, y) -> x – y    
    
// 4. 接收2个int型整数,返回他们的和    
(int x, int y) -> x + y    
    
// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)    
(String s) -> System.out.print(s)

# 2. #

String\[\] atp = \{"Rafael Nadal", "Novak Djokovic",    
       "Stanislas Wawrinka",    
       "David Ferrer","Roger Federer",    
       "Andy Murray","Tomas Berdych",    
       "Juan Martin Del Potro"\};    
List<String> players =  Arrays.asList(atp);    
    
// 以前的循环方式    
for (String player : players) \{    
     System.out.print(player + "; ");    
\}    
    
// 使用 lambda 表达式以及函数操作(functional operation)    
players.forEach((player) -> System.out.print(player + "; "));    
     
// 在 Java 8 中使用双冒号操作符(double colon operator)    
players.forEach(System.out::println);

不过暂时不支持强转,比如下面的这个：

List<Object> list=new ArrayList<Object>();
    list.forEach( objec ->{
        objec.forEach( objeee ->{
    
         });
    });

换成这个就对了

List<List> list=new ArrayList<List>();

# 3. #

// 使用匿名内部类    
btn.setOnAction(new EventHandler<ActionEvent>() \{    
          @Override    
          public void handle(ActionEvent event) \{    
              System.out.println("Hello World!");     
          \}    
    \});    
     
// 或者使用 lambda expression    
btn.setOnAction(event -> System.out.println("Hello World!"));

**复杂的：**

# **1.** #

Runnable runnable = () -> System.out.println("test lambda");  
         new Thread(runnable).start();

# **2.** #

Consumer<String> consumer = message -> System.out.println(message);  
        consumer.accept("hello java lambda ");

# **3.** #

BinaryOperator<Long> add = (a, b) -> a + b;  
        System.out.println(add.apply(66L, 22L));

# **4.** #

public static void main(String[] args){  
        int incr = 20;
        int myNumber = 10;
        modifyTheValue(myNumber,var -> var + incr + 100);
    }
    
    public static   void modifyTheValue(int valueToBeOperate,Function<Integer,Integer> function) {
        int newValue = function.apply(valueToBeOperate);//根据输入的参数，然后计算出结果
        System.out.println(newValue);
    }

注：（Function的apply有返回值）

# **5.** #

FunctionalInterface关键字是放在接口中的注解，用于标示此接口可用于函数式编程形式 如”() ->\{\}“ 的写法，形式如下

@FunctionalInterface只能用在中只有一个虚方法的接口中，但接口中可以有其他有某认实现的方法或者静态方法

接口

@FunctionalInterface
    public interface T {
        String getName(String name);
    
        default int getSpeed(){
            return 1;
        };
    
        default int flyMaxHight(){
            return 1000;
        }
        static void flyMaxDistance(){
            System.out.println("最远里程");
        }
    
    }

类

public static void main(String[] args){
    
        // 或者
       // plane(name-> "我是"+name );
          plane(name-> 1+name );
    }
    
    private static void plane(T t) {
        //static method may be invoked on containing interface class only(报错)
        //t.flyMaxDistance();
        T.flyMaxDistance();
        System.out.println(t.getSpeed());
        System.out.println(t.flyMaxHight());
        System.out.println(t.getName("卧槽"));
    }

# **6.** #

List<String> list = Arrays.asList("peter", "anna", "mike", "xenia");
    Collections.sort(list, new Comparator<String>() {
        @Override
        public int compare(String a, String b) {
            return b.compareTo(a);
        }
    });
    
    System.out.println(list);
    
    Collections.sort(list, (String a, String b) -> b.compareTo(a));
    
    Collections.sort(list, ( a,  b) -> b.compareTo(a));

# **7.** #

@FunctionalInterface  
interface Converter<F, T> \{  
    T convert(F from);  
\}  
Converter<String, Integer> converter = (from) -> Integer.valueOf(from);  
Integer converted = converter.convert("123");  
System.out.println(converted);    // 123

# **8.** #

允许你使用 :: 关键字来传递方法或者构造函数引用

# **9.** #

public static void main(String[] args) {
    
        int num = 1;
        Converter<Integer, String> stringConverter = (from) -> String.valueOf(from + num);
        
        stringConverter.convert(2);     // 3
        System.out.println(stringConverter.convert(2));
        System.out.println(stringConverter.convert(2));
    
       //报错
       //  int num = 1;
       //Converter<Integer, String> stringConverter =
       //     (from) -> String.valueOf(from + num);
       //num = 3;
    }

# **10.** #

Predicate<String> predicate = (s) -> s.length() > 0;
    
    System.out.println(predicate.test("foo"));
    System.out.println(predicate.negate().test("foo"));
    
    Predicate<Boolean> nonNull = Objects::nonNull;
    Predicate<Boolean> isNull = Objects::isNull;
    
    System.out.println(nonNull.test(true));
    System.out.println(isNull.negate().test(true));
    
    Predicate<String> isEmpty = String::isEmpty;
    Predicate<String> isNotEmpty = isEmpty.negate();
    
    System.out.println(isEmpty.test("T"));
    System.out.println(isEmpty.test(""));

# **11.** #

Function<String, Integer> toInteger = Integer::valueOf;
    Function<String, String> backToString = toInteger.andThen(String::valueOf);
    System.out.println(toInteger.apply("123")+5);
    System.out.println(backToString.apply("123")+6);

# **12.** #

List<String> list = Arrays.asList("aaa","bbb","a","ccc","aaa");
    
    //filter 方法
    list.stream().filter(e -> e.startsWith("a")).forEach(e -> System.out.println("filter方法匹配开头为a"+e+"  "));
    //map方法
    list.stream().map(e -> e.hashCode()).forEach(e -> System.out.println("map方法返回hashCode的值"+e));
    //peek方法
    list.stream().peek(e -> System.out.print(e.hashCode())).forEach(e -> System.out.println("< - peek方法在调用forEach方法前执行"+e));
    //limit方法
    list.stream().limit(2).forEach(e -> System.out.println("limit截断 现在只有两个元素"+e));
    //skip 方法
    list.stream().skip(2).forEach(e -> System.out.println("skip跳过 跳过了二个元素"+e));
    //distinct 方法
    list.stream().distinct().forEach(e -> System.out.println("distinct 元素中去掉重复值"+e));

# **13.** #

// 使用匿名内部类  
btn.setOnAction(new EventHandler<ActionEvent>() \{  
          @Override  
          public void handle(ActionEvent event) \{  
              System.out.println("Hello World!");   
          \}  
    \});  
  
// 或者使用 lambda expression  
btn.setOnAction(event -> System.out.println("Hello World!"));

# **14.** #

// 定义 filters  
Predicate<Person> ageFilter = (p) -> (p.getAge() > 25);  
Predicate<Person> salaryFilter = (p) -> (p.getSalary() > 1400);  
Predicate<Person> genderFilter = (p) -> ("female".equals(p.getGender()));

System.out.println("下面是年龄大于 24岁且月薪在$1,400以上的女PHP程序员:");  
phpProgrammers.stream()  
          .filter(ageFilter)  
          .filter(salaryFilter)  
          .filter(genderFilter)  
          .forEach((p) -> System.out.printf("%s %s; ", p.getFirstName(), p.getLastName()));

// 重用filters  
System.out.println("年龄大于 24岁的女性 Java programmers:");  
javaProgrammers.stream()  
          .filter(ageFilter)  
          .filter(genderFilter)  
          .forEach((p) -> System.out.printf("%s %s; ", p.getFirstName(), p.getLastName()));

# **15.** #

//计算 count, min, max, sum, and average for numbers  
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);  
IntSummaryStatistics stats = numbers  
          .stream()  
          .mapToInt((x) -> x)  
          .summaryStatistics();

System.out.println("List中最大的数字 : " + stats.getMax());  
System.out.println("List中最小的数字 : " + stats.getMin());  
System.out.println("所有数字的总和   : " + stats.getSum());  
System.out.println("所有数字的平均值 : " + stats.getAverage());