2. 程式人生 > >Java8新特性（lambda、Stream、Optional）

Java8新特性（lambda、Stream、Optional）

阿新 • • 發佈：2019-02-14

1、λ表示式

lambda表示式：λ表示式是Java8新增的一個特性，《Core Java》中的對它的解析是——“一個可傳遞的程式碼塊，可以在以後執行一次或多次”。
  • 從日常開發的角度來看，它可以簡化我們的很多程式碼（當然不止這一個原因），特別是很多匿名內部類的寫法都可以被λ表示式替換成一個語句。
  • λ表示式從本質上來看是語法糖，但它並不是簡單的匿名內部類的語法糖，λ表示式的內部實現機制也都不是採用匿名內部類，說到底還是效能原因。
  • 對於大多數情況來說，Lambda表示式要比匿名內部類效能更優。
// 使用匿名類的方式新建一個執行緒
new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello world !");
    }
}).start();
 
 
// 使用λ表示式的方式新建一個執行緒
new Thread(() -> System.out.println("Hello world !")).start();

lambda表示式的語法：
（parameters） → expression
                  或者
（parameters） → { statements; }  // 這種方式可以寫多條語句
lambda表示式的使用場景：
  • 匿名內部類（上文已展示）
  • 集合排序
  • 結合stream使用
public class Human {
    private String name;
    private int age;
 
    public Human() {
        super();
    }
    // standard getters and setters……
}


// 使用傳統的方式對集合進行排序：對集合進行排序要為Comparator建立一個匿名內部類用來排序：
new Comparator<Human>() {
	@Override
	public int compare(Human h1, Human h2) {
		return h1.getName().compareTo(h2.getName());
	}
}
@Test
public void givenPreLambda_whenSortingEntitiesByName_thenCorrectlySorted() {
	List<Human> humans = Lists.newArrayList(new Human("Sarah", 10), new Human("Jack", 12));
	Collections.sort(humans, new Comparator<Human>() {
		@Override
		public int compare(Human h1, Human h2) {
			return h1.getName().compareTo(h2.getName());
		}
	});
	Assert.assertThat(humans.get(0), equalTo(new Human("Jack", 12)));
}
// 使用λ表示式方式
@Test
public void whenSortingEntitiesByName_thenCorrectlySorted() {
	List<Human> humans = Lists.newArrayList(new Human("Sarah", 10), new Human("Jack", 12));
	humans.sort((Human h1, Human h2) -> h1.getName().compareTo(h2.getName()));
	Assert.assertThat(humans.get(0), equalTo(new Human("Jack", 12)));
}

2、Stream

Stream（流）是Java8的新增的一個庫，它最常見的用法是對集合中的資料進行操作，它就像一個高階版的Iterator，使用者只需要定義好對元素的操作，並將操作應用到元素上就好，而具體的實現演算法則交給類庫的設計者，這樣就很方便的將操作和演算法分開。所有流計算都有一種共同的結構：它們具有一個流來源、0 或多箇中間操作，以及一個終止操作。流的元素可以是物件引用 (Stream<String>)，也可以是原始整數 (IntStream)、長整型 (LongStream) 或雙精度 (DoubleStream)。
// 使用傳統的for迴圈的方式：
// 將每個userId查詢到的記錄放在List<UserBaseInfo>中
for (UserBaseInfo userBaseInfo : userBaseInfoList) {
    userId = userBaseInfo.getUserId();
    if (userIDandBaseInfoMap.containsKey(userId)) {
        userBaseInfos = userIDandBaseInfoMap.get(userId);
    } else {
        userBaseInfos = new ArrayList<>();
        userIDandBaseInfoMap.put(userId, userBaseInfos);
    }
    userBaseInfos.add(userBaseInfo);
}    
// 使用stream進行操作
Map<Long, List<UserBaseInfo>> userIDandBaseInfoMap = userBaseInfoList.stream()       
                               .collect(Collectors.groupingBy(UserBaseInfo::getUserId));  // 說明：Collection介面的預設方法建立流
建立stream的方式：
  • Stream介面的靜態工廠方法of （Java8裡介面可以帶靜態方法）
  • Collection介面預設方法或子類獲取流（Java8對Collection的增強）（見上文例子）
使用Stream介面建立流：
// stream介面的of方法有兩個過載的方法
Stream<String> stringStream = Stream.of("youzan");
 
Stream<Integer> integerStream = Stream.of(1, 2, 3, 5);
 
 
// 使用變長引數建立流返回的是一個Arrays的流（原始碼）
@SafeVarargs
@SuppressWarnings("varargs") // Creating a stream from an array is safe
public static<T> Stream<T> of(T... values) {
    return Arrays.stream(values);
}
 
 
// generator方法的方式
Stream.generate(new Supplier<Double>() {
    @Override
    public Double get() {
        return Math.random();
    }
});
Stream.generate(() -> Math.random());
Stream.generate(Math::random);

Java8對Collection介面的增強
public interface Collection<E> extends Iterable<E> {
    default Stream<E> stream() { // 介面中新增了Stream方法，讓集合類可以很方便的建立流
        return StreamSupport.stream(spliterator(), false);
    }
}
使用Stream介面建立流：
// stream介面的of方法有兩個過載的方法
Stream<String> stringStream = Stream.of("youzan");

Stream<Integer> integerStream = Stream.of(1, 2, 3, 5);


// 使用變長引數建立流返回的是一個Arrays的流（原始碼）
@SafeVarargs
@SuppressWarnings("varargs") // Creating a stream from an array is safe
public static<T> Stream<T> of(T... values) {
    return Arrays.stream(values);
}


// generator方法的方式
Stream.generate(new Supplier<Double>() {
	@Override
	public Double get() {
		return Math.random();
	}
});
Stream.generate(() -> Math.random());
Stream.generate(Math::random);
流的來源：
方法描述
Collection.stream()使用一個集合的元素建立一個流
Stream.of(T...)使用傳遞給工廠方法的引數建立一個流
Stream.of(T[])使用一個數組的元素建立一個流
Stream.empty()建立一個空流。
Stream.iterate(T first, BinaryOperator<T> f)建立一個包含序列 first, f(first), f(f(first)), ...的無限流
Stream.generate(Supplier<T> f)使用一個生成器函式建立一個無限流
IntStream.range(lower, upper)建立一個由下限到上限（不含）之間的元素組成的IntStream
IntStream.rangeClosed(lower, upper)建立一個由下限到上限（含）之間的元素組成的 IntStream
BufferedReader.lines()建立一個有來自 BufferedReader 的行組成的流
BitSet.stream()建立一個由 BitSet 中的設定位的索引組成的 IntStream
Stream.chars()建立一個與 String 中的字元對應的 IntStream

流的中間操作：
操作內容
filter(Predicate<T>)與預期匹配的流的元素
map(Function<T, U>)將提供的函式應用於流的元素的結果
flatMap(Function<T, Stream<U>>將提供的流處理函式應用於流元素後獲得的流元素
distinct()已刪除了重複的流元素
sorted()按自然順序排序的流元素
Sorted(Comparator<T>)按提供的比較符排序的流元素
limit(long)截斷至所提供長度的流元素
skip(long)丟棄了前 N 個元素的流元素
takeWhile(Predicate<T>)（僅限 Java 9）在第一個提供的預期不是 true 的元素處階段的流元素
dropWhile(Predicate<T>)（僅限 Java 9）丟棄了所提供的預期為 true 的初始元素分段的流元素


流的終止操作：
操作內容
forEach(Consumer<T> action)將提供的操作應用於流的每個元素
toArray()使用流的元素建立一個數組
reduce(...)將流的元素聚合為一個彙總值
collect(...)將流的元素聚合到一個彙總結果容器中
min(Comparator<T>)通過比較符返回流的最小元素
max(Comparator<T>)通過比較符返回流的最大元素
count()返回流的大小
{any,all,none}Match(Predicate<T>)返回流的任何/所有元素是否與提供的預期相匹配
findFirst()返回流的第一個元素（如果有）
findAny()返回流的任何元素（如果有）

3、Optional

Optional：Optional是Java8新引進的一個允許為null的容器物件，它的到來可以使程式設計師減少與NullPointException（NPE）打交道的次數。Optional提供了一種優雅的Java風格的方法來解決null安全問題。
// Java8之前想獲取一個實體的某一個屬性是這樣的
public String getName(Employee em) {
    if (em == null) {
        return "Unknow employee name";
    }


	return em.getName();
}


// 使用Optional優雅的獲取
public String getName(Employee em) {
    Optional.ofNullable(em).map(employee -> employee.getName()).orElse("Unknow employee name");
}

建立Optional物件：

  • of方法
  • ofNullable方法（推薦）
// 使用of方法，但是它仍然有可能報NPE
Optional<String> optional = Optional.of("youzan");


// 使用of方法，不會報NPE
Optional<String> optional = Optional.ofNullable("youzan");


// 通過原始碼來看為什麼of方法會報NPE
public static <T> Optional<T> of(T value) {
    return new Optional<>(value); // 新建一個物件
}
// 呼叫顯式建構函式去新建物件
private Optional(T value) {
    this.value = Objects.requireNonNull(value);
}
// Objects工具類的requireNonNull方法遇到null會報NPE
public static <T> T requireNonNull(T obj) {
    if (obj == null)
        throw new NullPointerException();
    return obj;
}


// 接下來還是通過原始碼看看ofNullable方法是怎麼樣做到允許null的
public static <T> Optional<T> ofNullable(T value) {
    return value == null ? empty() : of(value); // 如果value為null則呼叫empty方法
}
// 隱藏在empty方法中的祕密
public static<T> Optional<T> empty() {
    @SuppressWarnings("unchecked")
    Optional<T> t = (Optional<T>) EMPTY; // 返回一個EMPTY物件
    return t;
}
// EMPTY的廬山真面目
private static final Optional<?> EMPTY = new Optional<>();
// Optional提供的無參建構函式將返回一個值空的Optional物件
private Optional() {
    this.value = null; // value是用來儲存物件的值的
}

orElse方法：物件的值為null則返回引數傳進來的值
// 使用姿勢
String string = Optional.ofNullable("youzan").orElse("Unknow");


// orElse方法揭祕
public T orElse(T other) {
    return value != null ? value : other; // 如果當前的Optional物件為null則返回other
}

orElseGet方法：orElseGet與orElse方法類似，區別在於得到的預設值。orElse方法將傳入的字串作為預設值，orElseGet方法可以接受Supplier介面的實現用來生成預設值。
// orElseGet方法原始碼
public T orElseGet(Supplier<? extends T> other) {
    return value != null ? value : other.get();
}

orElseThrow方法：如果物件值為null則丟擲一個異常
// 使用姿勢
Optional.ofNullable(object).orElseThrow(NoSuchElementException::new);


// orElseThrow方法原始碼
public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
    if (value != null) {
        return value;
    } else {
        throw exceptionSupplier.get(); // 嗯，這裡能幫你丟擲一個異常就是了
    }
}
map方法：map方法用來對Optional例項的值執行一系列操作。通過一組實現了Function介面的lambda表示式傳入操作。
// 使用姿勢
Optional<String> upperName = name.map((value) -> value.toUpperCase());


// map方法原始碼
public<U> Optional<U> map(Function<? super T, ? extends U> mapper) {
    Objects.requireNonNull(mapper); // 如果形參mapper為null，則報NPE
    if (!isPresent())
        return empty(); // 返回一個不包含值的Optional物件
    else {
        return Optional.ofNullable(mapper.apply(value));
    }
}
// isPresent方法是檢視當前optional物件的值是否有值
public boolean isPresent() {
    return value != null;
}

flatMap方法：flatMap方法與map方法類似，區別在於mapping函式的返回值不同。map方法的mapping函式返回值可以是任何型別T，而flatMap方法的mapping函式必須是Optional。
filter方法：filter個方法通過傳入限定條件對Optional例項的值進行過濾。
// filter方法檢查給定的Option值是否滿足某些條件。
// 如果滿足則返回同一個Option例項，否則返回空Optional。
Optional<String> name = Optional.of("Sana");
Optional<String> longName = name.filter((value) -> value.length() > 6);
System.out.println(longName.orElse("The name is less than 6 characters")); // 輸出Sanaulla


相關推薦

Java8新特性（lambda、Stream、Optional）

1、λ表示式lambda表示式：λ表示式是Java8新增的一個特性，《Core Java》中的對它的解析是——“一個可傳遞的程式碼塊，可以在以後執行一次或多次”。從日常開發的角度來看，它可以簡化我們的很

java8新特性 （λ、stream 與 預設介面方法）

1.lambda λ表示式本質上是一個匿名方法，用來方便地實現函式介面。也就是說，λ表示式主要用於替換以前廣泛使用的內部匿名類。  讓我們來看下面這個例子：     public int add(int x, int y) {         return x + y;  

Java8新特性（三）方法引用、構造器引用、陣列引用

目錄： 1、方法引用 1.1、物件 :: 例項方法 1.2、類 :: 靜態方法 1.3、類 ::例項方法 2、構造器引用 2.1、介紹 2.2、使用 3、陣列引用 3.1、介紹 3.2、使用 1、方法引用 若lambda體中的內容有方法已經實現了，

java8新特性（方法引用、構造器引用）

前言： 接上一篇文章：Java8新特性（內建的核心函式式介面）http://blog.csdn.net/xinghuo0007/article/details/78603908 我們知道使用了L

Java8新特性（一）---Lambda表示式

Java8新特性之Lambda表示式 Lambda的語法格式 語法格式一：無引數，無返回值 語法格式二：有一個引數，並且無返回值 語法格式三：若只有一個引

看透Java8新特性：lambda表示式和Stream API

Java11前兩天都發布了，Java8還沒搞清都有啥，這就很尷尬了~ Java8 的新特性：Lambda表示式、強大的 Stream API、全新時間日期 API、ConcurrentHashMap、MetaSpace。Java8 的新特性使 Java 的執行速度更快、程式碼更少（Lambda 表示式）、便

java8新特性（四）：Stream流的使用

Java5的時候就引入了自動裝箱拆箱的功能， 在對包裝型別進行數學計算的時候，包裝型別就會被自動拆箱成基本型別， 而將一個基本型別的值賦值給一個包裝型別的變數或者放入集合中時基本型別又會被自動裝箱成包裝型別，這個過程是需要消耗計算效能的。Java8的包裝型別的流的計算過程中同樣包含了對基本型別的自動裝箱和拆箱

十分鐘學會Java8新特性：lambda表示式和Stream API

Java8 的新特性：Lambda表示式、強大的 Stream API、全新時間日期 API、ConcurrentHashMap、MetaSpace。總得來說，Java8 的新特性使 Java 的執行速度更快、程式碼更少、便於並行、最大化減少空指標異常。 這篇文章分享之前我還是要推薦下我

java8新特性之Lambda表達式入門

java8新特性 obj 返回值 報錯 java8 虛擬 ret UNC bject 一 什麽是Lambda表達式　　Lambda表達式：可以讓你的代碼更加的簡潔。ambda無法單獨出現，需要一個函數式接口來盛放，可以說lambda表達式方法體是函數式接口的實現，lambd

java8新特性之lambda

函數式 var ride urn fun 模擬實現 face 清晰 例如 一、什麽是lambda 在函數編程中，我們經常將方法作為參數來傳遞，這樣不僅結構清晰而且更容易去組織一個良好的代碼結構。例如Javascript寫法： <script type="text/j

Java8新特性03 Lambda表達式

表達 string ESS 特性 大括號 ret 方式 表達式 逗號 一. Lambda表達式概述 Lambda表達式是Java8中最大的變化。它允許我們將一個函數當作方法的參數，或者說把一段代碼當作數據使用。很多基於JVM平臺的語言一開始就支持Lambda表達式，比如Sc

基礎 | Java8新特性之Lambda表示式

Lambda表示式是Java8所引入的新特性之一，其基於函式式介面，以極大地減少程式碼冗餘，並提高程式碼的可讀性。 Lambda表示式的基本語法 參考答案： Java8中引入箭頭操作符（也叫Lambda操作符）將Lambda表示式拆分成左右兩部分： 左

Java8新特性之Lambda表示式學習二

大家好，又來到超超部落格大本營啦！歡迎大家...... 上一章我們講解了Lambda表示式的基礎語法，引數列表、變數等知識點，接下來我們接續探究Lambda的表示式、以及其中的方法引用。 一、Lambda的表示式： (1)如果表示式只有一行，那麼可以直接寫(不需要{}); (2)

Java8新特性之Lambda表示式學習一

       剛畢業入職新工作，在職崗位培訓時，老師在操作集合老使用Lambda表示式。這使一個之前完全沒有接觸過Lambda表示式的少年甚是苦惱，看不懂，閒餘時間決定搞一搞Lambda表示式到底是啥東西？底層原理怎麼實現的，接下來我將我的學習成果一起分享

Java8新特性之lambda表示式

     在瞭解lambda表示式之前，必須先了解函數語言程式設計、函式式介面和default方法。在Java8出來之前，別的程式語言中已經有了函數語言程式設計這種概念，只不過後來沒落了，不過在最近幾年又火起來了。在Java8中大力提倡我們使用函數語言程式設計，並且更新了一些

java8新特性（簡述十大新特性）

截止稿前，java10都已經發布了，現在我們來討論一下java8（2014年3月釋出）。 本文的討論，只是一個簡述，更加具體的，各位可以參照各自的專題講解 說在前面 你真的開始用JDK8了嗎？ 如果你沒有用上一些新特性，請別說自己使用了Java8。 Java 8可謂

Java8新特性：Lambda表示式和函式式介面

Java8新特性：速度更快，程式碼更少，stream API，便於並行，最大化減少空指標異常：Optional Lambda表示式 好處： Lambda是一個匿名函式，可以把lambda表示式理解為一

jdk8新特性（Lambda表示式）結合spring 執行緒池，一行程式碼實現多執行緒

1.配置spring 執行緒池 @Configuration @EnableAsync @ConfigurationProperties(prefix="threadpool") public class ExecutePoolConfiguration { @V

Java8新特性之Lambda表示式解析及其常見用法

Lambda表示式是Java8更新的一大新特性，與同期更新的Stream是此版本的最大亮點。 “這是你從來沒有玩過的全新版本” —– 扎扎輝 -> 舉個栗子 : 建立一個執行緒 //old Thread thread1 = new Thread(

Java8新特性（五）新日期時間的API

1、新時間日期API java.time – 包含值物件的基礎包 java.time.chrono – 提供對不同的日曆系統的訪問 java.time.format – 格式化和解析時間和日期 java.time.temporal – 包括底層框架和擴