Lambda表达式

• 语法一：无参数，无返回值
  () -> System.out.println(“Hello Lambda”);
• 语法二：有一个参数，并且无返回值
  (x) -> System.out.println(x);《若只有一个参数，(x) 小括号可以不写：x -> System.out.println(x);》
• 语法三：有两个以上的参数，有返回值，并且在Lambda体中有多条语句
  Comparator comparator = (x,y) -> {
  System.out.println(“语句n”);
  return Integer.compare(1,2);
  };
• 语法四：Lambda体中有只有一条语句时，return {}可以不写
  Comparator comparator = (x,y) -> Integer.compare(x,y);
• 语法五：Lambda表达式参数列表的数据类型可以不写，因为JVM编译器可以通过上下文推断出数据类型，即“类型推断”

package com.kb.Lambda;

import org.junit.Test;

import java.text.Collator;
import java.util.*;
import java.util.function.Consumer;
/**
 * 语法一：无参数，无返回值
 *            () -> System.out.println("Hello Lambda");
 *
 * 语法二：有一个参数，并且无返回值
 *             (x) -> System.out.println(x);
 *             《若只有一个参数，(x) 小括号可以不写：x -> System.out.println(x);》
 *
 * 语法三：有两个以上的参数，有返回值，并且在Lambda体中有多条语句
 *              Comparator<Integer> comparator = (x,y) -> {
 *                 System.out.println("语句n");
 *                return Integer.compare(1,2);
 *                };
 *
 * 语法四：Lambda体中有只有一条语句时，return  {}可以不写
 *             Comparator<Integer> comparator = (x,y) -> Integer.compare(x,y);
 *
 * 语法五：Lambda表达式参数列表的数据类型可以不写，因为JVM编译器可以通过上下文推断出数据类型，即“类型推断”
 *
 */
public class LambdaTest01 {

    @Test
   public void Test01(){
        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("匿名内部类");
            }
        };
        r1.run();

        System.out.println("-----------------------------------");

        Runnable r2 = () ->  System.out.println("Lambda无参数，无返回值");
        r2.run();
   }

   @Test
   public void Test02(){
        Consumer<String> consumer1 = (x) -> System.out.println(x);
        consumer1.accept("Lambda有一个参数，并且无返回值");

       System.out.println("-----------------------------------");

       Consumer<String> consumer2 = x -> System.out.println(x);
       consumer2.accept("Lambda有一个参数，并且无返回值 《若只有一个参数，(x) 小括号可以不写：x -> System.out.println(x);》");
   }


   @Test
   public void Test03(){
        Comparator<Integer> comparator = (x,y) -> {
            System.out.println("语句n");
            return Integer.compare(x,y);
        };
   }


    @Test
    public void Test04(){
        Comparator<Integer> comparator = (x,y) -> Integer.compare(x,y);

    }

    /**
     * 中文排序
     */
    @Test
    public void Test05(){
        List<String> list = Arrays.asList("谷歌", "腾讯", "百度", "淘宝");
        Collator collator = Collator.getInstance(Locale.CHINA);
        list.sort((string1, string2) -> collator.compare(string1, string2));
        System.out.println(list);
    }

    /**
     * 遍历list
     */
    @Test
    public void Test06(){
        List<String> list = new ArrayList<String>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("ddd");
        list.add("eee");
        list.add("fff");

        System.out.println("普通for循环输出");
        for (int i = 0; i < list.size(); i++){
            System.out.println(list.get(i));
        }
        System.out.println("在 Java 8 中使用双冒号操作符");
        list.forEach(System.out::println);

        System.out.println("使用 lambda 表达式以及函数操作");
        list.forEach((list2) -> System.out.println(list2));

        System.out.println("使用 lambda 表达式以及函数操作,输出ddd");
        list.forEach((list3) -> {
            if(list3.equals("ddd")){
                System.out.println(list3);
            }
        });
    }
}