Lambda相关

基本使用

        // 开启一个新的线程
       new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("helloword : "+Thread.currentThread().getName());
            }
        }).start();

(参数类型 参数名称) -> {
    代码体;
}
格式说明：

- (参数类型 参数名称):参数列表
- {代码体;} :方法体
- -> : 箭头，分割参数列表和方法体

例：
new Thread(() -> { System.out.println("helloword" +Thread.currentThread().getName()); })
                .start();

@FunctionalInterface注解 代表函数式接口

Lambda对集合排序

 List<Integer> list = new ArrayList<>();
list.add(1);
list.add(5);
list.add(4);
list.add(3);
list.add(7);
//--------------------------------------------------------------
list.sort((a,b)->a.compareTo(b));

list.sort(Comparator.comparing(a->a));

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

//对实体

  public static void main(String[] args) {
        List<Person> list = new ArrayList<>();
        list.add(new Person("周杰伦",33,175));
        list.add(new Person("刘德华",43,185));
        list.add(new Person("周星驰",38,177));
        list.add(new Person("郭富城",23,170));

//      Collections.sort(list, new Comparator<Person>() {
//          @Override
//         public int compare(Person o1, Person o2) {
//             return o1.getAge()-o2.getAge();
//        }
//      });

       Collections.sort(list,(Person o1,Person o2) -> {
            return o1.getAge() - o2.getAge();
        });

  
        for (Person person : list) {
            System.out.println(person);
        }
    }

//简洁版

List<User> list1 = new ArrayList<User>();
User user = new User("张三", "15", "男");
User user1 = new User("李四", "10", "男");
list1.add(user);
list1.add(user1);
//1、年龄升序
list1.sort((a,b) -> a.getAge().compareTo(b.getAge()));
//2、姓名降序排列
list1.sort(Comparator.comparing(User::getName).reversed());
//等价于 2
list1.sort(Comparator.comparing(a->((User)a).getAge()).reversed());
//3、先按性别排，如果年龄相同，再按年龄排序
// 多条件 thenComparing
list1.sort(Comparator.comparing(User::getSex).reversed().thenComparing(User::getAge));

Stream API

e00ab6633e72a2dd8a612b66d0d4390.png

例：

      // 定义一个List集合
        List<String> list = Arrays.asList("张三","张三丰","成龙","周星驰");
        // 1.获取所有 姓张的信息
        // 2.获取名称长度为3的用户
        // 3. 输出所有的用户信息
        list.stream()
                .filter(s->s.startsWith("张"))
                .filter(s->s.length() == 3)
                .forEach(s->{
                    System.out.println(s);
                });
    //     .forEach(System.out::println);

//map
 Stream.of("1", "2", "3","4","5","6","7")
                //.map(msg->Integer.parseInt(msg))
                .map(Integer::parseInt)
                .forEach(item->{
                    System.out.println(item.getClass());
                });
//sorted
 Stream.of("1", "3", "2","4","0","9","7")
                 //.map(msg->Integer.parseInt(msg))
                 .map(Integer::parseInt)
                 //.sorted() // 根据数据的自然顺序排序
                 .sorted((o1,o2)->o2-o1) // 根据比较强指定排序规则
                 .forEach(System.out::println);
//match 是否匹配
boolean b = Stream.of("1", "3", "3", "4", "5", "1", "7")
                .map(Integer::parseInt)
                //.allMatch(s -> s > 0) // 元素是否有任意一个满足条件
                //.anyMatch(s -> s >4) // 元素是否都满足条件
                .noneMatch(s -> s > 4)// 元素是否都不满足条件
                ;
        System.out.println(b);
//reduce 聚合操作
    Integer sum = Stream.of(4, 5, 3, 9)
                // identity默认值
                // 第一次的时候会将默认值赋值给x
                // 之后每次会将 上一次的操作结果赋值给x y就是每次从数据中获取的元素
                .reduce(0, (x, y) -> {
                    System.out.println("x="+x+",y="+y);
                    return x + y;
                });
        System.out.println(sum);


        // 获取 最大值
        Integer max = Stream.of(4, 5, 3, 9)
                .reduce(0, (x, y) -> {
                    return x > y ? x : y;
                });
        System.out.println(max);

//map和reduce的组合
 // 1.求出所有年龄的总和
        Integer sumAge = Stream.of(
                new Person("张三", 18)
                , new Person("李四", 22)
                , new Person("张三", 13)
                , new Person("王五", 15)
                , new Person("张三", 19)
        ).map(Person::getAge) // 实现数据类型的转换
                .reduce(0, Integer::sum);
        System.out.println(sumAge);

        // 2.求出所有年龄中的最大值
        Integer maxAge = Stream.of(
                new Person("张三", 18)
                , new Person("李四", 22)
                , new Person("张三", 13)
                , new Person("王五", 15)
                , new Person("张三", 19)
        ).map(Person::getAge) // 实现数据类型的转换，符合reduce对数据的要求
                .reduce(0, Math::max); // reduce实现数据的处理
        System.out.println(maxAge);
        // 3.统计 字符 a 出现的次数
        Integer count = Stream.of("a", "b", "c", "d", "a", "c", "a")
                .map(ch -> "a".equals(ch) ? 1 : 0)
                .reduce(0, Integer::sum);
        System.out.println(count);

Optional类 常用判空

/**
     * Optional中的常用方法介绍
     *   get(): 如果Optional有值则返回，否则抛出NoSuchElementException异常
     *          get()通常和isPresent方法一块使用
     *   isPresent():判断是否包含值，包含值返回true，不包含值返回false
     *   orElse(T t):如果调用对象包含值，就返回该值，否则返回t
     *   orElseGet(Supplier s):如果调用对象包含值，就返回该值，否则返回 Lambda表达式的返回值
     */
    @Test
    public void test03(){
        Optional<String> op1 = Optional.of("zhangsan");
        Optional<String> op2 = Optional.empty();

        // 获取Optional中的值
        if(op1.isPresent()){
            String s1 = op1.get();
            System.out.println("用户名称:" +s1);
        }

        if(op2.isPresent()){
            System.out.println(op2.get());
        }else{
            System.out.println("op2是一个空Optional对象");
        }

        String s3 = op1.orElse("李四");
        System.out.println(s3);
        String s4 = op2.orElse("王五");
        System.out.println(s4);

        String s5 = op2.orElseGet(()->{
            return "Hello";
        });
        System.out.println(s5);
    }