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表達式來替代原來的寫法。