java8新特性lambda表达式01

我们可以看看java8这个新特性，几乎是大大减轻了程序员码字的工作流，简洁而优雅的写法，受到不少java爱好者的一致认同。下面来看看lambda表达式到底是个什么东东。
让我们看看下面这段代码，他进行了一些字符串筛选和条件查询的操作。

package yick.demo.lambda;

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

public class LambdaDemo1 {

    public LambdaDemo1() {

    }

    public static void filter(String findstr) {
        List<String> strList = new ArrayList();
        for (int i = 0; i < 10; i++) {
            strList.add(String.valueOf(i));
        }
        Optional<String> optional1 = strList.stream().filter(s -> s.equals(findstr)).findFirst();
        Optional<String> optional2 = strList.stream().filter(s -> Integer.valueOf(s) > 5).findFirst();
        System.out.print(optional1.isPresent() + "\n");
        System.out.print(optional2.isPresent() + " " + optional2.get());

    }

    public static void main(String[] args) {
        LambdaDemo1.filter("12");
    }

}

输出的结果是

false
true 6

很明显我们可以看到过往我们进行数组的条件筛选和复杂查询时都必须自己写遍历方法或者筛选的写法，但是lambda表达式帮我们大大减轻了这一工作量。只需一行字，就实现了10几行代码实现到的功能，是不是特别过瘾。这个是数组进行一些普通筛选的功能。

另外我们看看，如何进行更复杂的操作。例如去重

public static void distinct() {
        List<String> strList = new ArrayList();
        strList.add("1");
        strList.add("1");
        strList.add("2");
        strList.add("3");
        strList.add("3");
        System.out.print(strList.toString() + "\n");
        List<String> list = strList.stream().distinct().collect(Collectors.toList());
        System.out.print(list.toString());
    }

    public static void main(String[] args) {
        LambdaDemo1.distinct();
    }

我们看看结果,很符合我们想要的东西

[1, 1, 2, 3, 3]
[1, 2, 3]

但是这仍然不够复杂，让我们再置入我们常用的业务情景去。

public static void distinct() {
        List<Item> strList = new ArrayList();
        List<String> temp = new ArrayList();
        strList.add(new Item("1", "陈翔"));
        strList.add(new Item("1", "陈翔"));
        strList.add(new Item("2", "刘翔"));
        strList.add(new Item("3", "大翔"));
        strList.add(new Item("3", "大翔"));
        System.out.print(strList.toString() + "\n");
        List<Item> list = strList.stream().filter(v -> {
            boolean flag = !temp.contains(v.getId());
            temp.add(v.getId());
            return flag;

        }).collect(Collectors.toList());
        System.out.print(list.toString());
    }

    static class Item implements Serializable, Comparable<Item> {
        private String name;

        private String id;

        public Item() {

        }

        public Item(String id, String name) {
            this.id = id;
            this.name = name;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public String getId() {
            return id;
        }

        public void setId(String id) {
            this.id = id;
        }

        @Override
        public String toString() {
            return "[name=" + name + ", id=" + id + "]";
        }

        @Override
        public int compareTo(Item o) {
            if (Integer.valueOf(this.getId()) > Integer.valueOf(o.getId())) {
                return -1;// 降序由大到小
            } else if (Integer.valueOf(this.getId()) < Integer.valueOf(o.getId())) {
                return 1;
            }
            return 0;
        }

    }

    public static void main(String[] args) {
        LambdaDemo1.distinct();
    }

让我们看看这输出结果:

[[name=陈翔, id=1], [name=陈翔, id=1], [name=刘翔, id=2], [name=大翔, id=3], [name=大翔, id=3]]
[[name=陈翔, id=1], [name=刘翔, id=2], [name=大翔, id=3]]

十分漂亮，这就是我们平时场景使用比较多的去重方式，是不是觉得特别方便呢。
既然有去重，那怎么能少得了排序呢，过去我们使用比较多的是数组自带排序方法，当然这得看个人习惯，我们更注重两者的效率是否一致呢？来简单的测试一下。

public static void sort() {
        List<Item> strList = new ArrayList();
        strList.add(new Item("1", "刘翔"));
        strList.add(new Item("3", "陈翔"));
        strList.add(new Item("5", "万翔"));
        strList.add(new Item("2", "大翔"));
        strList.add(new Item("4", "小翔"));

        Long timeLong = System.currentTimeMillis();
        System.out.print(strList.toString() + "\n" + timeLong);

        Collections.sort(strList);

        System.out.print(strList.toString() + "\n" + (System.currentTimeMillis() - timeLong) * 0.001 + "\n");

        timeLong = System.currentTimeMillis();
        List<Item> temp = strList.stream().sorted().collect(Collectors.toList());
        System.out.print(temp.toString() + " " + (System.currentTimeMillis() - timeLong) * 0.001 + "\n");

    }

    public static void main(String[] args) {
        LambdaDemo1.sort();
    }

让我们看看结果，实践出真知

[[name=万翔, id=5], [name=小翔, id=4], [name=陈翔, id=3], [name=大翔, id=2], [name=刘翔, id=1]]
0.001
[[name=万翔, id=5], [name=小翔, id=4], [name=陈翔, id=3], [name=大翔, id=2], [name=刘翔, id=1]]
0.061

这么一来我们还是发觉系统自带的还是比较快些，lambda表达式只是充当一个可用性比较高的选择，更多需要自己去试验。
今天的介绍到此为止，下期再见吧！
代码地址

有你的支持，我会更努力哦！！！