lambda简单案列

public static void main(String[] args) {

        List<user1> list = new ArrayList<>();
        user1 u1 = new user1();
        u1.setId(10);
        u1.setName("1");
        u1.setPwd("1");
        u1.setAmount(10000L);
        list.add(u1);


        user1 u2 = new user1();
        u2.setId(2);
        u2.setName("2");
        u2.setPwd("2");
        u2.setAmount(5000L);
        list.add(u2);

        user1 u3 = new user1();
        u3.setId(3);
        u3.setName("3");
        u3.setPwd("3");
        u3.setAmount(2000L);
        list.add(u3);


        //list中某一个值--list
        List<String> collect1 = list.stream().map(user1::getName).collect(Collectors.toList());
        //System.out.println(collect1);


        //list--方法,方法必须是静态的.入参是遍历集合的泛型
        List<user1> collect2 = list.stream().map(lanbuda::convert1).collect(Collectors.toList());
        //System.out.println(collect2);

        //list--map，根据某一个字段做key，分组
        Map<Integer, List<user1>> collect3 = list.stream().collect(Collectors.groupingBy(user1::getId, Collectors.toList()));
       //System.out.println(collect3);

        //list--map，list的某一个字段做key，list整体做value
        Map<Integer, user1> mapp = list.stream().collect(Collectors.toMap(user1::getId, Function.identity()));
        //System.out.println("mapp: " + mapp);
        //System.out.println("mapp --> : " + mapp.get(1).getPwd());


         //是不是有一个数据满足规则
         Boolean  aBoolean = list.stream().filter(u -> u.getId() == 1 && u.getName().equals("1")).findFirst().isPresent();
        System.out.println(aBoolean);

         //是不是有一个数据满足规则
         Boolean  bBoolean = list.stream().anyMatch(user -> user.getId() == 1 && user.getName().equals("1"));
        System.out.println(bBoolean);

         //是不是所有数据满足规则
         Boolean  cBoolean = list.stream().allMatch(user -> user.getId() == 1 && user.getName().equals("1"));
        System.out.println(cBoolean);

         //取出满足规则的数据放到集合中
         List<user1> collect = list.stream().filter(m -> m.getId() == 1).collect(Collectors.toList());
        System.out.println(collect);

         //判断集合是否为空
         Boolean first = list.stream().findFirst().isPresent();
        System.out.println(first);

         //遍历集合
            list.stream().forEach( m -> {
                try{
                    int i = 1/0;
                }catch (Exception e){
                    System.out.println(m.getId());
                }
            });

        //将集合中某一字段的值相加
        Long reduce = list.stream()
                .filter(m -> !m.getId().equals(10))
                .map(d -> d.getAmount())
                .reduce(0L, (a, b) -> a + b);
        System.out.println("reduce : "+reduce);

        //如果对象为null，则返回0. 否则返回这个数据对应的字段数值
        user1 u4 = null;
        Integer num = Optional.ofNullable(u4)
                            .map(user1::getId)
                            .orElse(0);
        System.out.println(num);

        //如果对象为null或者空对象，则返回空字符串. 否则返回这个数据对应的数据
        String str = Optional.ofNullable(u4)
                .map(user1::getName)
                .orElse("kong");
        System.out.println(str);

        //如果集合为null或者空集合，则返回null，否则返回第一条数据
        List<user1> list1 = null;
        user1 user1 = Optional.ofNullable(list1)
                .orElse(Lists.newArrayList())
                .stream()
                .findFirst()
                .orElse(null);
        System.out.println(user1);
    }

    public static user1 convert1(user1 u) {
        user1 u4 = new user1();
        if (u.getId() == 1) {
            return null;
        }
        u4.setId(u.getId());
        u4.setName(u.getName());
        u4.setPwd(u.getPwd());
        return u4;
    }










import lombok.Data;

@Data
public class user1 {

    private Integer id;
    private String name;
    private String pwd;
    private Long amount;
}