JAVA 8 新特性 Lamdba表达式（二）

一、Lamdba的语法

(参数类型1 参数1,参数类型2 参数2,…) -> { 方法体 };

Lambda表达式就是一个匿名函数，不关注方法名，只关注参数和方法体。

Lambda表达式组成三要素：括号（），箭头->，代码块{}

二、Lambda表达式和匿名内部类区别

1、匿名内部类可以是：接口、抽象类、或者具体类
Lambda 表达式只能是：接口

2、匿名内部类：接口中可以多个或者一个方法
Lambda 表达式：接口中的只能有一个方法

3、匿名内部类：编译之后会产生单独的 .class 文件
Lambda 表达式：编译之后不会有单独的 .class 文件出现，对应的字节码会在运行的时候动态生成

三、Lamdba的使用

1、多线程

Lambda表达式可以与Java中的函数式接口一起使用

private static  void t1() {
        //从匿名类到lambda转换
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("hello");
            }
        };
        runnable.run();

        //lambda表达式
        //左边是参数列表 （）
        //右边是执行的功能{}
        //  -> 操作符
        Runnable r1 = () -> System.out.println("hello");
       r1.run();
}

2、排序

Lambda表达式可以用于Java中的排序算法中

   private static void t2() {
        TreeSet<String> tree = new TreeSet<>(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                int result = o1.length()-o2.length();
                //比较字符串
                return  (result==0?o1.compareTo(o2):result);

            }
        });

        //添加数据比较，字符串长度小的排在前面
        tree.add("zhang");
        tree.add("win");
        tree.add("apple");
        tree.add("back");
        System.out.println(tree);

        TreeSet<String> tree2 =new TreeSet<>((String o1,String o2)->{
            int result = o1.length()-o2.length();
            //比较字符串
            return  (result==0?o1.compareTo(o2):result);

        }) ;
        //添加数据比较，字符串长度小的排在前面
        tree2.add("zhang");
        tree2.add("win");
        tree2.add("apple");
        tree2.add("back");
        System.out.println(tree2);
    }

3、集合

注意：stream()和forEach()）一起使用，使集合的处理更加简单、灵活和易于读写

  private static void t4() {
        List<String> strs = Arrays.asList("张三", "李四", "王五","王菲");
        for (String str:
            strs ) {
            System.out.println(str);
        }

        //lambda表达式
        strs.stream().forEach(name -> System.out.println("姓名："+name));
    }

4、映射

Lambda表达式可以用于将一个集合中的元素映射到另一个集合中

   private static void t5() {
        List<String> names = Arrays.asList("John", "Mike", "Zhang","Peter");
        System.out.println(names);
        List<String> up = names.stream().map(String::toLowerCase).collect(Collectors.toList());
        System.out.println(up);
    }

5、过滤

Lambda表达式可以用于过滤集合中的元素

 private static void t6() {
        List<Integer> numbers = Arrays.asList(15, 72, 18, 52, 35, 66);
        System.out.println(numbers);
        List<Integer> result = numbers.stream().filter(n -> n % 3 == 0).collect(Collectors.toList());
        System.out.println(result);
    }

6、聚合

Lambda表达式可以用于聚合集合中的元素，例如，计算集合中的元素之和、平均值、最大值、最小值等。

  private static void t7() {
        List<Integer> numbers = Arrays.asList(5, 2, 8, 12, 3, 6);
        System.out.println(numbers);
        // 从0开始累加数据
        int sum = numbers.stream().reduce(0,(a, b) -> a + b);
        System.out.println("总和: " + sum);

       double avg= numbers.stream().mapToInt(Integer::intValue).average().orElse(0.0);
        System.out.println("平均值："+avg);

        int max= numbers.stream().mapToInt(Integer::intValue).max().orElse(0);
        System.out.println("最大值："+max);
    }

7、函数式编程

Lambda表达式可以使Java更加接近函数式编程，使代码更加简洁和易于理解。

interface MyInterfaces {
    int doing(int x, int y);
}

   private static void t8() {
        MyInterfaces my = (a, b) -> a * b;
        int result = my.doing(8, 16);
        System.out.println(result);
    }

8、并行计算

Lambda表达式可以与Java中的并行计算API（如Java 8中的Parallel Streams和Fork/Join框架）一起使用，使计算更加高效和快速。

// 返回一个顺序流
default Stream<R> stream();
 
// 返回一个并行流
default Stream<E> parallelStream();

  private static void t9() {
        List<Integer> numbers = new ArrayList<>();
        //1000w
        for (int i = 1; i <= 10000000; i++) {
            numbers.add(i);
        }
//        假设有一个大型的整数列表，需要计算其中所有元素的立方和。
        long sum = numbers.parallelStream().mapToLong(i -> i * i * i ).sum();
        System.out.println("计算所有元素的立方和: " + sum);