JDK8新特性lambda和stream

前些日子小熙简单了解了下jdk8的新特性，觉得其中的lambda和stream比较有意思，所以分享下。

1.lambda表达式

举几个小例子

（1）. 简单的遍历循环与操作
lambda表达式也是方法的简写，只不过强调了入参而无出参，是封闭式的
前端的箭头函数也是方法的简写，同理但箭头是两个杠的

        ArrayList<Integer> integers = new ArrayList<>();

        ArrayList<Integer> newIntegers = new ArrayList<>();

        Collections.addAll(integers, 1, 2, 3, 4, 5);

        // lambda中得抒写（简单遍历数字）
//        integers.forEach(integer -> System.out.println(integer));

        // 调用Scala中的方法，序列化打印（结合Scala语言简写）
        integers.forEach(System.out::println);

        // 使用foreach方法，其效果差不多（遍历中加些操作）
        integers.forEach(integer -> newIntegers.add(integer + 1));

        System.out.println(\"newIntegers:\" + newIntegers);

（2）. 应用于比较器
简单应用

 String[] p s = {\"Rafael Nadal\", \"Novak Djokovic\",
                \"Stanislas Wawrinka\", \"David Ferrer\",
                \"Roger Federer\", \"Andy Murray\",
                \"Tomas Berdych\", \"Juan Martin Del Potro\",
                \"Richard Gasquet\", \"John Isner\"};

        // 通过lambda表达式构建比较器，还是比较方便的
        Comparator<String> sortByLastLetter =
                (String s1, String s2) ->
                        (s1.charAt(s1.length() - 1) - s2.charAt(s2.length() - 1));
        // 通过数组工具类调用排序方法，传入比较器规则
        Arrays.sort(p s, sortByLastLetter);

        System.out.println(\"sortByLastLetter：\"+Arrays.toString(p s));

        // 打印该索引位置的字符
        System.out.println(p s[0].charAt(0));

        // 打印该字符位置的索引，字符区分大小写
        System.out.println(p s[0].indexOf(\'S\'));
        System.out.println(p s[0].indexOf(\'s\'));

具体多种方式应用

String[] p s = {\"Rafael Nadal\", \"Novak Djokovic\",
                \"Stanislas Wawrinka\", \"David Ferrer\",
                \"Roger Federer\", \"Andy Murray\",
                \"Tomas Berdych\", \"Juan Martin Del Potro\",
                \"Richard Gasquet\", \"John Isner\"};

// 1.1 使用匿名内部类根据 name 排序 p s
        Arrays.sort(p s, new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                return (s1.compareTo(s2));
            }
        });

        // 1.2 使用 Lambda   排序 p s
        Comparator<String> sortByName = (String s1, String s2) -> (s1.compareTo(s2));
        Arrays.sort(p s, sortByName);

// 1.3 也可以采用如下形式:
        Arrays.sort(p s, (String s1, String s2) -> (s1.compareTo(s2)));

//        其他的排序如下所示。 和上面的示例一样,代码分别通过匿名内部类和一些lambda表达式来实现Comparator :

// 1.1 使用匿名内部类根据 surname 排序 p s
        Arrays.sort(p s, new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                return (s1.substring(s1.indexOf(\" \")).compareTo(s2.substring(s2.indexOf(\" \"))));
            }
        });

// 1.2 使用 Lambda   排序,根据 surname
        Comparator<String> sortBySurname = (String s1, String s2) ->
                (s1.substring(s1.indexOf(\" \")).compareTo(s2.substring(s2.indexOf(\" \"))));
        Arrays.sort(p s, sortBySurname);

// 1.3 或者这样,怀疑原作者是不是想错了,括号好多...
        Arrays.sort(p s, (String s1, String s2) ->
                (s1.substring(s1.indexOf(\" \")).compareTo(s2.substring(s2.indexOf(\" \"))))
        );

// 2.1 使用匿名内部类根据 name lenght 排序 p s
        Arrays.sort(p s, new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                return (s1.length() - s2.length());
            }
        });

// 2.2 使用 Lambda   排序,根据 name lenght
        Comparator<String> sortByNameLenght = (String s1, String s2) -> (s1.length() - s2.length());
        Arrays.sort(p s, sortByNameLenght);

// 2.3 or this
        Arrays.sort(p s, (String s1, String s2) -> (s1.length() - s2.length()));

// 3.1 使用匿名内部类排序 p s, 根据最后一个字母
        Arrays.sort(p s, new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                return (s1.charAt(s1.length() - 1) - s2.charAt(s2.length() - 1));
            }
        });

// 3.2 使用 Lambda   排序,根据最后一个字母
        Comparator<String> sortByLastLetter =
                (String s1, String s2) ->
                        (s1.charAt(s1.length() - 1) - s2.charAt(s2.length() - 1));
        Arrays.sort(p s, sortByLastLetter);

// 3.3 or this，推荐
        Arrays.sort(p s, (String s1, String s2) -> (s1.charAt(s1.length() - 1) - s2.charAt(s2.length() - 1)));
    }

（3）. 线程应用

    /**
     * 经过测试调用run方法比直接start要快
     */
    @Test
    public void thread(){
        // 1.1使用匿名内部类
        new java.lang.Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(\"Hello world1 !\");
            }
        }).start();

// 1.2使用 lambda  
        new java.lang.Thread(() -> System.out.println(\"lambda替代匿名内部类\")).start();
        java.lang.Thread thread = new java.lang.Thread(() -> System.out.println(\"Hello world2 !\"));
        thread.run();


// 2.1使用匿名内部类
        Runnable race1 = new Runnable() {
            @Override
            public void run() {
                System.out.println(\"Hello world3 !\");
            }
        };

// 2.2使用 lambda  
        Runnable race2 = () -> System.out.println(\"Hello world4 !\");
        Runnable runnable = () -> System.out.println(\"新线程\");
// 直接调用 run 方法(没开新线程哦!)
        race1.run();
        race2.run();
        runnable.run();
        
        // 可重入锁
        ReentrantLock reentrantLock = new ReentrantLock();
        reentrantLock.lock();
        reentrantLock.unlock();
    }

2. stream简单使用

        Random random = new Random();
        // ints()将整数转为整数流，limit(10)用于获取指定数量的流（这里指定的是10），forEach遍历循环，System.out::println单个输出结果
        random.ints().limit(10).forEach(System.out::println);

        random.ints().limit(10).sorted().forEach(System.out::println);

        // asDoubleStream是转为小数流
        System.out.println(\"小数流：\"+random.ints().asDoubleStream());

        List<Integer> integers = new ArrayList<>();
        Collections.addAll(integers,1,2,3,4,5);

        System.out.println(\"integers：\"+integers.stream());

        List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
        // 获取对应的平方数
        // 先把集合变成流对象，用map进行遍历（lambda处理操作），接着对结果进行去重（调用去重方法），最后使用集合工具添加
        // Collectors 类实现了很多归约操作，例如将流转换成集合和聚合元素。Collectors 可用于返回列表或字符串：
        // List<Integer> squaresLists = numbers.stream().map( i -> i*i).distinct().collect(Collectors.toList());
        // parallelStream是多管比Stream的单管更快
        List<Integer> squaresLists = numbers.parallelStream().map( i -> i*i).distinct().collect(Collectors.toList());

        // 遍历循环结果
        squaresLists.forEach(System.out::println);


        List<String>strings = Arrays.asList(\"abc\", \"\", \"bc\", \"efg\", \"abcd\",\"\", \"jkl\");
        // 获取空字符串的数量，首先将集合类转为流对象，接着调用过滤方法，使用lambda表达式实现过滤操作，最后调用count方法记过滤总数。
        long count = strings.stream().filter(string -> string.isEmpty()).count();

        long count1 = numbers.stream().filter(number -> number > 5).count();
        System.out.println(\"数组集合中大于5的个数：\"+count1);

        // 最后的collect方法可以调用Collectors.toList()方法将过滤的结果加到新集合中
        List<Integer> collect = numbers.stream().filter(number -> number > 5).collect(Collectors.toList());
        System.out.println(\"数组集合中大于5的数为：\"+collect);

嗯，小熙分享的以上入门是可以的。如果想要深入学习可自寻查找资料。