alambda

Lambda表达式的应用

1. Lambda表达式实际上就是匿名内部类的简化版本
2. Lambda表达式是JDK1.8引入的一个最重要的新特性，另外一个就是集合的流式编程
3. Lambda表达式是java为了扩展函数式编程引入的。
4. Lambda表达式可以理解为是一个匿名函数(匿名方法：方法名没有名字)
5. Lambda表达式只能作用于函数式接口（有且只有一个抽象方法的接口）

package 优快云.day01;

public class _01 {
    public static void main(String[] args) {
        /*2. 测试实现类 */
        Test t1 = new Test();
        t1.print();
        /*3. 使用匿名内部类的方式，实现NoParameterNoRetrun接口，打印"我一定能学会java"，并测试*/
        NoParameterNoReturn npnr = new NoParameterNoReturn() {
            @Override
            public void print() {
                System.out.println("我一定能学会java");
            }
        };
        npnr.print();
        /*4. 使用lambda表达式，实现NoParameterNoReturn接口，打印"哈哈哈，我哭了..."，并测试*/

        NoParameterNoReturn npnr2 = ()-> System.out.println("哈哈哈，我哭了。。。");
        npnr2.print();
        /*5. 使用lambda表达式，实现OneParameterNoReturn接口，打印"'我喜欢'+形参"，并测试打印,传入'苹果'*/

        OneParameterNoReturn opnr = m-> System.out.println("我喜欢"+m);
        opnr.print("苹果");
        /*6. 使用lambda表达式，实现MuilParameterNoReturn接口，打印两个参数拼接的效果，测试传入"我今年","18"*/

        MuilParameterNoReturn mpnr = (m,n)-> System.out.println(m+n);
        mpnr.print("我今年",18);
        /*7. 使用lambda表达式，实现NoParameterReturn接口，计算两个随机数，区间[25,40]的和"，测试*/

        NoParameterReturn npr = ()->{
            int a = (int) (Math.random()*16+25);
            int b = (int) (Math.random()*16+25);
            return a+b;
        };
        int calculate = npr.calculate();
        System.out.println(calculate);
        /*8. 使用lambda表达式，实现OneParameterReturn接口，计算形参的立方，测试传入3*/

        OneParameterReturn opr = m->{
            return m*m*m;
        };
        int calculate1 = opr.calculate(3);
        System.out.println(calculate1);
        /*9. 使用lambda表达式，实现MuilParameterReturn接口，计算两个形参的立方和，测试传入3和4*/
        MuilParameterReturn mpr =(m,n)->{
            return m*m*m+n*n*n;
        };
        int calculate2 = mpr.calculate(3, 4);
        System.out.println(calculate2);

    }
}




/*1.使用实现类的方式，实现NoParameterNoRetrun接口,打印"java编程真简单" */
class Test implements NoParameterNoReturn{

    @Override
    public void print() {
        System.out.println("java编程真简单");
    }
}

//里面的抽象方法 没有形参，也没有返回值
interface NoParameterNoReturn{
    void print();
}
// 一个形参，没有返回值
interface OneParameterNoReturn{
    void print(String info);
}
// 多个形参，没有返回值
interface MuilParameterNoReturn {
    void print(String info,int age);
}
//没有形参，带返回值
interface NoParameterReturn{
    int calculate();
}
//一个形参，带返回值
interface OneParameterReturn{
    int calculate(int a);
}
//多个形参，带返回值
@FunctionalInterface  //注解是用来校验是否为函数式接口
interface MuilParameterReturn {
    int calculate(int a,int b);
}

其他的测试

package 优快云.day01;

import java.util.*;

public class _02 {

        public static void main(String[] args) {
            /*测试第一种：集合的排序*/
            List<String> list = new ArrayList<>();
            list.add("michael");
            list.add("david");
            list.add("bob");
            list.add("lucy");
            //按照字符串的长度降序：  比较器使用了lambda表达式的方法

            Collections.sort(list, (a, b) -> b.length() - a.length());

            System.out.println(list);

            /*测试第二种：集合的迭代*/
            Integer[] arr = new Integer[]{4,5,10,7,2};
            List<Integer> nums = Arrays.asList(arr);

            nums.forEach(System.out::println);
            Set<Integer> set = new HashSet<>(nums);
            set.forEach(System.out::println);
            System.out.println("--------------Map的迭代-------------------");
            Map<String,Integer> map=new HashMap<>();
            map.put("张三",18);
            map.put("李四",19);
            map.put("王五",17);
            map.put("赵六",28);
            map.keySet().forEach(System.out::println);
            map.entrySet().forEach(System.out::println);
            map.values().forEach(System.out::println);

            List<Integer> list1 = Arrays.asList(18, 19, 17, 20, 17);
            List<Integer> list2 = new ArrayList<>(list1);

            list2.removeIf(m->m.equals(17));
            System.out.println(list2);

        }
    }

allMatch: 当数据源中的所有元素都满足匹配条件，才返回true
anyMatch: 当数据源中的任意一个元素满足匹配条件，就返回true
noneMatch:当数据源中的所有元素都不满足匹配条件，返回true

package 优快云.day01;

import java.util.ArrayList;
import java.util.List;

public class _03 {
    public static void main(String[] args) {
        List<Integer> nums = new ArrayList<Integer>();
        nums.add(1);
        nums.add(2);
        nums.add(3);
        nums.add(4);
        nums.add(5);
//        boolean b = nums.stream().allMatch(e -> e < 10);
//        System.out.println(b);
//        boolean b = nums.stream().anyMatch(e -> e < 2);
//        System.out.println(b);
        boolean b = nums.stream().noneMatch(e -> e < 0);
        System.out.println(b);


    }
}

FindFirst()  与   FindAny()

针对于串行的流，获取的都是第一个元素

针对于并行的流，获取的元素应该不同

package 优快云.day01;

import java.util.ArrayList;
import java.util.List;

public class _04 {
    public static void main(String[] args) {
        List<Integer> nums = new ArrayList<Integer>();
        nums.add(1);
        nums.add(2);
        nums.add(3);
        nums.add(4);
        nums.add(5);
        //串行的流
        int i = nums.stream().findFirst().get();
        int i1 = nums.stream().findAny().get();
        System.out.println(i);
        System.out.println(i1);


        //并行
        int i2 = nums.parallelStream().findFirst().get();
        int i3 = nums.parallelStream().findAny().get();
        System.out.println(i2+" "+i3);

    }
}

filter()

过滤出满足条件的数据

package 优快云.day01;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

public class _05 {
    public static void main(String[] args) {
        List<Integer> nums = new ArrayList<Integer>();
        nums.add(1);
        nums.add(2);
        nums.add(3);
        nums.add(4);
        nums.add(5);
        nums.add(2);
        nums.add(4);


        List<Integer> c1 = nums.stream().filter(m -> m % 2 != 0).collect(Collectors.toList());
        System.out.println(c1);
       nums.stream().distinct().forEach(Class1::m1);
    }
}
class Class1{
    public static<T> void m1(T t){
        System.out.println(t);
    }
}

排序

sorted(): 升序排序
sorted(Comparator c): 自定义比较规则
limit(long size): 表示截取流中的前size个元素
skip(long size): 表示跳过前size个元素

package 优快云.day01;

import java.util.ArrayList;
import java.util.List;

public class _06 {
    public static void main(String[] args) {
        List<Integer> nums = new ArrayList<Integer>();
        nums.add(3);
        nums.add(2);
        nums.add(5);
        nums.add(4);
        nums.add(1);

        nums.stream().sorted((a,b)->b-a).forEach(System.out::println);
        System.out.println("-------------------------------");
        nums.stream().limit(2)
                .sorted((a,b)->b-a).forEach(System.out::println);
        System.out.println("-------------------------------");
        nums.stream().filter(e->e!=2).sorted().skip(2).forEach(System.out::println);


    }
}

map(.....) :将元素映射成另外一种类型

package 优快云.day01;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class _07 {
    public static void main(String[] args) {
        List<Integer> nums = new ArrayList<Integer>();
        nums.add(3);
        nums.add(2);
        nums.add(5);
        nums.add(4);
        nums.add(1);


//        比如：将上述的元素映射成字符串类型
        List<Integer> c1 = nums.stream().map(e -> e).collect(Collectors.toList());

        System.out.println(c1);
        int sum = nums.stream().mapToInt(e -> 1).sum();
        System.out.println(sum);

    }
}

 flatMap

扁平式映射

一般针对的都是集合元素仍然是一个集合。

 普通的集合 [1,2,3,4,5]

 集合元素是集合的： [[1,2],[1,3,4],[2,4,5]]

扁平式映射：就是将元素是集合的这种特殊集合，转成普通的集合

如 将 右边的集合 [[1,2,10],[1,3,4],[2,4,5]]

转成下面的形式：  [1,2,10,1,3,4,2,4,5]

package 优快云.day01;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;

public class _08 {
    public static void main(String[] args) {
        List<List<Integer>> out = new ArrayList<>();
        out.add(Arrays.asList(1,2,3));
        out.add(Arrays.asList(4,5,6));
        out.add(Arrays.asList(3,4,5));

        long count = out.stream().flatMap(Collection::stream).count();
        System.out.println(count);
        double asDouble = out.stream().flatMap(e -> e.stream())
                .mapToInt(e -> e).average().getAsDouble();
        System.out.println(asDouble);

    }
}