Java8新特性概述

       要说java8的新特性，网上一搜一大把，但是网上说的玄乎但是我们也要自己去实践到底有多么的神乎其神。下面就是lambda这个大家都耳熟能详的东东了。

List<Integer> values = Arrays.asList(1,2,3,4,5,6);

        int total = 0;
        for(int e : values){
            total += e*2;
        }

        //System.out.println(total);

        System.out.println(
                values.stream().map(e -> e*2)
                .reduce(0,(c,e) -> c+e));

下面我们可以通过专用的筛选语句来选择：这里是找到大于2的偶数并乘以2 结果输出

        //the double of the first even number and  gt than 2 in the list
        //第一种写法
        int result = 0;
        for(int e:values){
            if(e>3 && e%2==0){
                result = e*2;
                break;
            }
        }
        //System.out.println(result);

        //第二种
        System.out.println(
           values.stream()
                .filter(e -> e>3)
                .filter(e -> e%2 ==0)
                .map(e -> e*2)
                .findFirst()
                .orElse(0)
        );

第三种就是通过方法来判别，我们在使用的时候可以使用方法来筛选。

package com.cwnu.main;

import java.util.Arrays;
import java.util.List;

/**
 * Created by yangy on 2015/12/27.
 */
public class Sample {

    public static void main(String[] args) {
        List<Integer> values = Arrays.asList(1, 2, 3, 4, 5, 6);
        System.out.println(
                values.stream()
                    .filter(Sample::isGT3)
                    .filter(Sample::isEven)
                    .map(Sample::doubleInt)
                    .findFirst()
                    .orElse(0));
    }


    public static boolean isEven(int number){
        System.out.println("isEven number:"+number);
        return number % 2 == 0;
    }

    public static boolean isGT3(int number){
        System.out.println("isGT3 number:"+number);
        return number > 3;
    }

    public static int doubleInt(int number){
        System.out.println("doubleInt number:"+number);
        return number*2;
    }
}

下面再来看一个，我们采用到Predicate类，从词意我们可以理解为符合条件的判定。

我们可以举个例子：

package com.cwnu.main;

import java.util.function.Predicate;

/**
 * Created by yangy on 2015/12/27.
 */
public class PredicateTest {
    public static void main(String[] args) {

        Predicate<String> i  = (s)-> s.length() > 5;

        System.out.println(i.test("java2s.com "));
    }
}

结果符合长度大于5的判定，所以输出的是 true

下面我们来看正式的demo

package com.cwnu.main;

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;

/**
 * Created by yangy on 2015/12/27.
 */
public class Sample2 {
    //传统
    public static int totalValues(List<Integer> numbers,Predicate<Integer> selector){
        int total = 0;
        for(int e:numbers){
            if(selector.test(e)) total += e;
        }
        return total;
    }


    public static int totalValues2(List<Integer> numbers,Predicate<Integer> selector){
        return numbers.stream().filter(selector).reduce(0,(c,e) -> c + e);
    }



    public static void main(String[] args) {
        long start1 = System.nanoTime();
        List<Integer> values = Arrays.asList(1,2,3,4,5,6);
        System.out.println(totalValues(values, e -> true));
        System.out.println(totalValues(values, e -> e % 2 == 0));
        System.out.println(totalValues(values, e -> e % 2 != 0));
        long end1 = System.nanoTime();
        System.out.println("waste time totalValues:"+(end1-start1));


        //通过执行时间的结果，我们可以看到第二次做了很多优化
        long start2 = System.nanoTime();
        List<Integer> values2 = Arrays.asList(1,2,3,4,5,6);
        System.out.println(totalValues2(values2, e -> true));
        System.out.println(totalValues2(values2, e -> e % 2 == 0));
        System.out.println(totalValues2(values2, e -> e % 2 != 0));
        long end2 = System.nanoTime();
        System.out.println("waste time totalValues2:"+(end2-start2));
    }
}

同样是满足条件后对数值的相加，第二个方法的Lambda速度在第二次执行后就明显优化了。大家可以测试一下。

以后我会在项目中经常使用java8 的东西来试试效果。新特性，用起来吧！！！，最近在狂补linux知识，弄完总结给大家一些新技能get

另外，元旦快来了，新的一年2016，大家元旦快乐，新年快乐！

2018-06-11 更新：

对一个字符串长度的链表做一个排序，Comparator这个接口有很多匹配规则，

     List<String> list = new ArrayList<>();
        list.add("bbbb");
        list.add("ccccc");
        list.add("aaa");
        list.sort(comparingInt(String::length));
        System.out.println(list);

这里是对String的长度进行排序，排序算法就在comparingInt（Comparator类）的实现里面，这样看起来很整洁。

当我们返回一个带序列的List的时候我们就可以考虑用lambda表达式来替代原来的写法。