lamdba表达式实用小实例

lambda表达式实用实例

java8新特性lambda的使用

//最基本的遍历方法
List<User> users = Lists.newArrayList();
        users.add(new User("1", "张三"));
        users.add(new User("2", "李四"));
	//一般遍历方式
	for (User user : users) {
            System.out.println(user.toString());
        }
    //采用lambda来遍历List集合
	users.forEach(System.out::println);

流的中间操作筛选和切片
//filter:过滤元素中的某些数据
//limit(n):获取第n个元素
// skip(n):跳过n元素,配合limit可实现分页
// distinct:通过流元素中的hashCode() 和 equals来去重

List<Integer> streamMid = Arrays.asList(1, 2, 5, 5, 6, 7, 9);
        //筛选数值大于5的数据
        streamMid.stream().filter(c -> c > 5).collect(Collectors.toList());
        //获取前两个元素
        streamMid.stream().limit(2);
        //跳过前二个元素
        streamMid.stream().skip(2);
        //过滤小于10的元素，在去重，在跳过前两个元素，获取第2个元素
        streamMid.stream().filter(c -> c <        
        10).distinct().skip(2).limit(2);
        public static void main(String[] args) {
        List<Student> students = Lists.newArrayList();
        students.add(new Student("张三", 10));
        students.add(new Student("李四", 20));
        students.add(new Student("李四", 42));
        students.add(new Student("王五", 30));
      
        List<String> mapList = Arrays.asList("a,b,c", "1,2,3");
        //去除当前list中的,和空格 转成一个新的元素 sout abc 123
        Stream<String> stringStream = mapList.stream().map(s -> s.replace(",", ""));
        /**
         * 知识点 流的中间操作筛选和切片中filter过滤元素中的某些数据
         * 获取年龄为30岁并且第一个字是王的（startsWith获取开头的数据）
         */

        List<Student> collectName = students.stream().filter(c -> c.getAge() == 30 && c.getName().startsWith("王")).collect(Collectors.toList());
        System.out.println("-----------------获取年龄为30岁并且第一个字是王的"+collectName);
        /**
         * 知识点map,distinct
         * 根据名字去重
         */
        students.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(
                () -> new TreeSet<>(Comparator.comparing(Student::getName))
        ), ArrayList::new)).forEach(System.out::println);

        /**
         * 知识点sorted
         * 根据年龄进行升序排列
         *流的中间操作排序(sort)
         */
        students.sort(Comparator.comparing(Student::getAge));
        System.out.println("-------------------------------------根据年龄进行升序排列"+students);
    }
        List<Student> students = Lists.newArrayList();
        students.add(new Student("aa", 10));
        students.add(new Student("bb", 20));
        students.add(new Student("aa", 30));
        students.add(new Student("dd", 40));
     //先根据姓名进行升序姓名相同年龄升序（thenComparing然后根据什么排序的意思）
	  students.sort(Comparator.comparing(Student::getName).thenComparing(Student::getAge)).;
	 //String类型是可以直接进行排序的 因为它本身就实现了Comparable接口
	 List<String> strings = Arrays.asList("dd", "aa", "ff");
	  strings.stream().sorted();

 /**
         * 冒泡排序
         *      比较相邻元素,第一个大于第二个就进行交换
         *      一直到最后一个为最大数
         *      针对所有的元素执行以上操作,除了最后一个 故而用length-1
         *      第一次是对第n个数进行n-1 进行到最后一个n是最大的
         *      第二次是对第n-1个数进行n-2次比较,进行到最后一个第n-1次是最大的
         *       for (int i = 0; i < num.length - 1; i++) {
         *             for (int j = 0; j < num.length - 1 - i; j++) {
         *                 if (num[j] > num[j + 1]) {
         *                     int temp = num[j];
         *                     num[j] = num[j + 1];
         *                     num[j + 1] = temp;
         *                 }
         *             }
         *         }
         *                 Integer[] num = new Integer[]{1, 5, 8, 2, 9, 7};
         */

 List<User> users = Lists.newArrayList();
        users.add(new User("1", "张三"));
        users.add(new User("2", "李四"));
        users.add(new User("0", "王五"));

//过滤id为1的和名字为张三的User并转成List
 List<User> collect = users.stream().filter(c -> c.getId().equals("1")&&c.getName().equals("张三")).collect(Collectors.toList());

//过滤id为1的User并转成List
 List<User> collect = users.stream().filter(c -> c.getId().equals("1")).collect(Collectors.toList());

//对当前list进行去重
distinct.collect(Collectors.toList()).forEach(c->{
            System.out.println(c.toString());
});

Optional<User> first = users.stream().findFirst();//获取当前list中的第一个对象


for (Trader trader:traders) { };类似  traders.forEach(c->{System.out.println(); });

filter里面要跟一个boolean表达式
.var 有返回值的用这个都可以自动生成对象
获取演员名字为3个字的三个人 
 ArrayList<String> manArray = new ArrayList<>();
        manArray.add("刘德华");
        manArray.add("成龙");
        manArray.add("吴彦祖");
        manArray.add("周润发");
        manArray.add("周星驰");
        manArray.add("吴京");
 s.length就是当前这个字符串的长度==3  然后limit就是和sql的差不多

manArray.stream().filter(s -> s.length() == 3).limit(3).collect(Collectors.toList()).forEach(System.out::println);



 List<Trader> traders = Lists.newArrayList();
        traders.add(new Trader(1, "赵六", new Date()));
        traders.add(new Trader(2, "王五", new Date()));
        traders.add(new Trader(3, "李四", new Date()));
        traders.add(new Trader(4, "张三", new Date()));
        traders.add(new Trader(5, "张三", new Date()));

List<Integer> collect = traders.stream().map(Trader::getId).collect(Collectors.toList());
System.out.println("==============获取id列表");

traders.stream().filter(c -> c.getName().equals("张三")).forEach(System.out::println);
System.out.println("==============获取name=张三的 数据");

traders.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(Trader::getName))), ArrayList::new)).forEach(System.out::println);
System.out.println("==============去除名字相同的数据");

traders.stream().filter(c -> c.getId() > 1).collect(Collectors.toList()).forEach(System.out::println);
System.out.println("==============获取id>1的数据,并转为集合");

待续。。

本文地址：https://blog.csdn.net/weixin_53111201/article/details/111870833