2. 程式人生 > >Java8中的 lambda 和Stream API

Java8中的 lambda 和Stream API

阿新 • • 發佈：2019-02-19
基本 -- 入參 lean limit 數組 結構 不同的 由於

前言

? 由於項目中用到了比較多有關於 Java8 中新的東西，一開始自己只是會寫，但是寫起來不太順，然後就在網上找到了一個很好的關於Java8新特性的視頻，所以就進行了學習了一下，以下是自己對 lambda 表達式和 Stream API 的筆記和相應的理解。 視頻地址，有興趣的可以自行觀看。

Java8 新特性

  1. 速度更快 更換了數據結構，內存結構（JVM）
  2. 代碼更少了（Lambda表達式）
  3. 強大的Stream API
  4. 便於並行 fork join (串行切換並行)
  5. 最大化減少空指針異常 Optional

Lambda表達式

? 在說 Lambda 之前，首先要說的是函數式接口。這個可以說是為了 Lambda 表達式而存在的一個東西。那麽什麽是函數式接口？

函數式接口

定義： 接口中只有一個抽象接口。
像 java.util.function 下的所有接口都是函數式接口。Java1.8提供@FunctionalInterface檢測一個接口是否是一個函數式接口。
eg: java.util.function 包下的 Consumer 接口代碼

@FunctionalInterface
public interface Consumer<T> {

    void accept(T t);

// jdk 1.8 接口可以有默認實現
    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

了解了什麽是函數式接口後，lambda 表達式就很好理解了。

? "->" 是 lambda 表達式的符號 左側表示函數式接口中抽象方法的參數列表，右側表示你對這個方法的實現。
舉個例子eg：

public class Test{
    public static void main(String[] args){
         Consumer consumer = x-> System.out.println(x);
         consumer.accept(1);
    }
}

輸出 1；

四大函數式接口

我們一般對函數式接口的使用的時候，都會對其進行封裝。

消費性接口

? Consumer 只有一個抽象方法名為 accept，參數列表只有一個泛型t，無返回值。參數的數據類型有類決定
eg:

/**
 * @ClassName ConsumerTest
 * @Description 消費型接口， 消費字符串字段 打印輸出
 * @Author ouyangkang
 * @Date 2019-02-18 15:46
 **/
public class ConsumerTest {

    public static void main(String[] args) {
        test("hello",x-> System.out.println(x));
    }

    public static <T> void test(T t, Consumer<T> consumer) {
        consumer.accept(t);
    }
}

輸出：hello
? 如果需要多個參數列表的話，也可以在 java.util.function 包下找到相應的函數式接口 比如 ObjLongConsumer。其他的可以自行查看

供給型接口

Supplier 只有一個抽象方法名為 get，參數列表為空，有返回值，返回值得數據類型為T。

/**
 * @ClassName SupplerTest
 * @Description 供給型接口 字符串拼接
 * @Author ouyangkang
 * @Date 2019-02-18 15:53
 **/
public class SupplerTest {

    public static void main(String[] args) {
        String hello = test("hello ", () -> "word!");
        System.out.println(hello);
    }

    public static String test(String str,Supplier<String> supplier){
        return str + supplier.get();
    }
}

輸出為：hello word!
? 如果需要返回得數據為基本數據類型，可以在 java.util.function 包下找到相應的函數式接口 比如：getAsLong 其他的可以自行查看

函數型接口

? Function<T, R> 只有一個抽象方法名為 apply，參數列表只有一個參數為T，有返回值，返回值的數據類型為R。

/**
 * @ClassName FunctionTest
 * @Description 函數式接口 將字符串轉換成大寫的
 * @Author ouyangkang
 * @Date 2019-02-18 16:01
 **/
public class FunctionTest {


    public static void main(String[] args) {
        String test = test("hello", x -> x.toUpperCase());
        System.out.println(test);
    }


    public static String test(String str , Function<String,String> function){
        return function.apply(str);
    }
}

輸出為：HELLO
? 如果需要多個入參，然後又返回值的話，可以在 java.util.function 包下找到相應的函數式接口 比如 BiFunction。其他的可以自行查看

斷言型接口

? 斷言型又名判斷型。 Predicate 只有一個抽象方法名為 test，參數列表只有一個參數為 T，有返回值，返回值類型為 boolean。

/**
 * @ClassName PredicateTest
 * @Description 斷言型接口，判斷字符串大小是否大於6
 * @Author ouyangkang
 * @Date 2019-02-18 16:16
 **/
public class PredicateTest {
    public static void main(String[] args) {
        boolean hello = test("hello", x -> x.length() > 6);
        System.out.println(hello);
    }
    public static boolean test(String str, Predicate<String> predicate){
        return predicate.test(str);
    }
}

輸出為： false

Stream API

? Stream 作為 Java 8 的一大亮點，它與 java.io 包裏的 InputStream 和 OutputStream 是完全不同的概念。Stream中間操作，多個中間操作可以連接起來形成一個流水線，除非流水線上觸發了終止操作，否則中間不會執行任何處理！而終止操作時會一次性全部處理，稱為惰性處理。要進行流操作首先要獲取流。有4中方法可以獲取流。

  1. 獲取流 通過集合系列提供的stream方法和 parallelStream()（並行流）方法獲取流
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        // 常用獲取流的方式
        Stream<Integer> stream = list.stream();
    }
  1. 通過Arrays.stream() 將數組轉換成流
    public static void main(String[] args) {
        int[] a = new int[]{1,2,3,4};
        IntStream stream = Arrays.stream(a);
        
    }
  1. 通過Stream.of今天方法創建流
    public static void main(String[] args) {
        Stream<Integer> stream = Stream.of(1, 2, 3);
    }
  1. 創建無限流
    public static void main(String[] args) {
        Stream<Integer> iterate = Stream.iterate(0, x -> x + 2);
    }

所有的對流的操作可以分為4種，分別為篩選與分片，映射，排序，終結（歸約，收集）

篩選與分片

操作有filter,distant,limit,skip。
filter ： 過濾操作,方法參數為斷言型接口
eg:

 public static void main(String[] args) {
        Stream<Integer> stream = Stream.of(1, 2, 3);
        stream.filter(x->x != 2).forEach(x-> System.out.println(x));
    }

輸出：
text 1 3

distinct ： 去重操作，方法無參數
limit ： 獲取前幾條數據，方法參數為long
skip ： 跳過前多少條數據，然後獲取後面所有的。 方法參數為long

映射

常用操作有 map ，flatMap。
map: 對原數據進行處理，並返回處理後的數據。 方法參數為函數型接口。
eg:

  public static void main(String[] args) {
       Stream<Integer> stream = Stream.of(1, 2, 3);
       stream.map(x->x*2).forEach(System.out::println);
    }

輸出：

2
4
6

flatMap ： 使原來流種的原有數據一個一個整合在另一個流中。方法參數為函數型接口，但是返回值為流。
eg:

    public static void main(String[] args) {
        List<String> list = Arrays.asList("a", "b", "c");
        List<String> list2 = Arrays.asList("f","d");
        list.stream().flatMap(x->list2.stream().map(y-> x + y)).forEach(System.out::println);
    }

排序

常用操作有sort自然排序，合sort參數為排序器的定制排序
自然排序eg:

public static void main(String[] args) {
        Stream<Integer> stream = Stream.of(1, 2, 3);
        stream.sorted().forEach(System.out::println);
    }

輸出：

1
2
3

定制排序

    public static void main(String[] args) {
        Stream<Integer> stream = Stream.of(1, 2, 3);
        stream.sorted((x,y)->-Integer.compare(x,y)).forEach(System.out::println);
    }

輸出：

3
2
1

終止操作

  • allMatch 檢查是否匹配所有元素 方法參數為斷言型接口
  • anyMatch 檢查是否匹配所有元素 方法參數為斷言型接口
  • noneMatch 檢查是否沒有匹配所有元素 方法參數為斷言型接口
  • findFirst 返回第一個元素 無方法參數
  • findAny 返回當前流的任意元素 無方法參數
  • count 返回流中的元素總個數 無方法參數
  • max 返回流的最大值 無方法參數
  • min 返回流中的最小值 無方法參數

歸約

reduce : 歸約 -- 可以將流中的元素反復結合起來，得到一個值。
eg:

 public static void main(String[] args) {
        List<Integer> list1 = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
        Integer reduce = list1.stream().reduce(11, (x, y) -> x + y);
        System.out.println(reduce);
    }

輸出 ： 66

收集

? 這個是非常常用的一個操作。 將流裝換為其他形式。接收到一個Collector接口的實現，用於給Stream中的元素匯總的方法。用collect方法進行收集。方法參數為Collector。Collector可以由Collectors中的toList()，toSet(),toMap(Function(T,R) key,Function(T,R) value)等靜態方法實現。

  • toList() 返回一個 Collector ，它將輸入元素 List到一個新的 List 。
  • toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper) 返回一個 Collector ，它將元素累加到一個 Map ，其鍵和值是將所提供的映射函數應用於輸入元素的結果。
  • toSet() 返回一個 Collector ，將輸入元素 Set到一個新的 Set 。
    eg:

User類

@Data
@ToString
public class User {
    private String name;

    private Integer age;

    private Integer salary;
}
   public static void main(String[] args) {
         List<User> users = Arrays.asList(new User("張三", 19, 1000),
                new User("張三", 58, 2000),
                new User("李四", 38, 3000),
                new User("趙五", 48, 4000)
        );
        List<String> collect = users.stream().map(x -> x.getName()).collect(Collectors.toList());
        Set<String> collect1 = users.stream().map(x -> x.getName()).collect(Collectors.toSet());
        Map<Integer, String> collect2 = users.stream().collect(Collectors.toMap(x -> x.getAge(), x -> x.getName()));
        System.out.println(collect);
        System.out.println(collect1);
        System.out.println(collect2);
    }

輸出：

[張三, 張三, 李四, 趙五]
[李四, 張三, 趙五]
{48=趙五, 19=張三, 38=李四, 58=張三}

分組

? Collectors.groupingBy()方法是 返回 Collector “由基團”上的類型的輸入元件操作實現 T ，根據分類功能分組元素。這個是非常常用的操作。
比如你要對名字相同的進行分組。
groupingBy(Function<? super T,? extends K> classifier)
eg:

    public static void main(String[] args) {
        List<User> users = Arrays.asList(new User("張三", 19, 1000),
                new User("張三", 58, 2000),
                new User("李四", 38, 3000),
                new User("趙五", 48, 4000)
        );
        Map<String, List<User>> collect3 = users.stream().collect(Collectors.groupingBy(x -> x.getName()));
        System.out.println(collect3);
    }

輸出：{李四=[User{name=‘李四‘, age=38, salary=3000}], 張三=[User{name=‘張三‘, age=19, salary=1000}, User{name=‘張三‘, age=58, salary=2000}], 趙五=[User{name=‘趙五‘, age=48, salary=4000}]}

當然還有其他的一些比較復雜的分組操作，實際代碼看業務來進行實現。

總結

? java8中的lambda表達式可能一開始用的時候還不是很熟悉，但是只要熟悉了，你會發現非常的好用，而且lambda表達式結合stream API可以進行編寫自己的工具類。在平常項目中可以非常的省時間，提高寫代碼的效率。我現在給出一個List轉Map的工具類。

public class CollectionStream {
    public static void main(String[] args) {
        List<User> users = Arrays.asList(new User("張三", 19, 1000),
                new User("張三", 58, 2000),
                new User("李四", 38, 3000),
                new User("趙五", 48, 4000)
        );
        Map<Integer, Integer> map = listToMap(users, x -> x.getAge(), x -> x.getSalary());
        System.out.println(map);
    }

    /**
     * @Author ouyangkang
     * @Description list 轉map key不能相同 ，如果相同會報錯。 方法對 源數據，key，value過濾null。
     * @Date 9:27 2019/2/19
     * @param source 源數據
     * @param key
     * @param value
     * @return java.util.Map<K,V>
    **/
    public static <DTO, K, V> Map<K, V> listToMap(List<DTO> source, Function<? super DTO, ? extends K> key, Function<? super DTO, ? extends V> value) {
        Objects.requireNonNull(source, "source not null");
        Objects.requireNonNull(key, "key not null");
        Objects.requireNonNull(value, "value not null");
        Map<K, V> map = source.stream()
                .filter(dto -> dto != null)
                .filter(dto -> key.apply(dto) != null)
                .filter(dto -> value.apply(dto) != null)
                .collect(Collectors.toMap(key, value));
        return map;
    }
}

Java8中的 lambda 和Stream API

相關推薦

Java8中的 lambda 和Stream API

基本 -- 入參 lean limit 數組 結構 不同的 由於 前言 ? 由於項目中用到了比較多有關於 Java8 中新的東西，一開始自己只是會寫，但是寫起來不太順，然後就在網上找到了一個很好的關於Java8新特性的視頻，所以就進行了學習了一下，以下是自己對 lambda

Java8實戰Lambda和Stram API學習

nba lis bool date UC AD action print family public class Trader{ private String name; private String city; public Trader(St

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

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

Java8：lambda表示式和Stream API

Java8 的新特性：Lambda表示式、強大的 Stream API、全新時間日期 API、ConcurrentHashMap、MetaSpace。總得來說，Java8 的新特性使 Java 的執行速度更快、程式碼更少、便於並行、最大化減少空指標異常。 本篇部落格將以筆者

java8 Lambda表示式和Stream Api

兩個用於測試的類 員工: public class Employee { private int id; private String name; private int age; private double salary;

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

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

Java8 新特性 Lambda & Stream API

目錄Lambda & Stream API1 Lambda表示式1.1 為什麼要使用lambda表示式1.2 Lambda表示式語法1.3 函式式介面1.3.1 什麼是函式式介面？1.3.2 如何理解函式式介面1.3.3 定義函式式介面1.3.4 函式式介面作為引數傳遞1.4 方法引用與構造器引用1.

kafka中生產者和消費者API

actor 成功 edm icc per class 持久化 spout payment 使用idea實現相關API操作，先要再pom.xml重添加Kafka依賴： <dependency> <groupId>

JAVA8新特性之 Stream API

重要的 Stream API  ： java.util.Stream.* Stream提供了一種高效且簡易處理資料的方式 注意：1.Stream自己不會儲存元素            2.對Stream進行操作不會改變資料來源，相反，

我們一起來學java8的lambda表示式Stream

Java 8 函數語言程式設計風格 Java 迄今為止最令人激動的特徵。這些新的語言特徵允許採用函式式風格來進行編碼，我們可以用這些特性完成許多有趣的功能。這些特性如此有趣以至於被認為是不合理的.他們說會影響計算速度,但是雖然是真的,但是存在皆合理. 所以我們摒棄缺點,研究優點. 演練  

Java8中 Date和LocalDateTime的相互轉換

一.在Java 8中將Date轉換為LocalDateTime 方法1: 將Date轉換為LocalDatetime，我們可以使用以下方法： 1.從日期獲取ZonedDateTime並使用其方法toLocalDateTime（）獲取LocalDateTime 2.使用L

java8 中 lambda函式的使用

什麼是lambda？ lambda表示式是一段可以傳遞的程式碼，它的核心思想是將面向物件中的傳遞資料變成傳遞行為。 我們之前使用runnable介面是使用匿名內部類的方式 Runnable r = new Runnable() { @Override pub

java8中 map和flatmap的共同點和區別，以及兩者的例項解析

在函式式語言中，函式作為一等公民，可以在任何地方定義，在函式內或函式外，可以作為函式的引數和返回值，可以對函式進行組合。由於指令式程式設計語言也可以通過類似函式指標的方式來實現高階函式，函式式的最主要的好處主要是不可變性帶來的。沒有可變的狀態，函式就是引用透明（Referen

JavaSE | Lambda| Optional| Stream API

 JDK1.8新特性 * JDK1.8或Java8的新特性： * 1、介面：預設方法、 靜態方法 * 2、Lambda表示式和StreamAPI * 3、Optional類 * 4、新的日期時間API * * Lambda表示式：為了簡化程式碼，使得Java支援

Java8中Lambda表示式總結

// 1. 不需要引數,返回值為 5 () -> 5 // 2. 接收一個引數(數字型別),返回其2倍的值 x -> 2 * x // 3. 接受2個引數(數字),並返回他們的差值 (x, y) -> x – y // 4. 接收2個int型整數,返回他們的

Java8學習筆記之Stream API

Stream是Java8引入的一個重度使用lambda表示式的API。 Stream可以用流的方式處理資料集合，在Java8之前，我們處理這些集合，是需要迭代器的，比如iterator，這是外部迭代；而Stream是內部迭代，我們不用關心集合內部元素是如何

JDK8新特性lambda和stream

前些日子小熙簡單瞭解了下jdk8的新特性，覺得其中的lambda和stream比較有意思，所以分享下。 1.lambda表示式 舉幾個小例子 （1）. 簡單的遍歷迴圈與操作 lambda表示式也是方法的簡寫，只不過強調了入參而無出參，是封閉式的 前端的箭頭函式也是方法的簡寫，同

Java8中Lambda表示式的使用（看懂即可）

簡介 (譯者注:雖然看著很先進，其實Lambda表示式的本質只是一個"語法糖",由編譯器推斷並幫你轉換包裝為常規的程式碼,因此你可以使用更少的程式碼來實現同樣的功能。本人建議不要亂用,看懂別人的程式碼即可，因為這就和某些很高階的黑客寫的程式碼一樣,簡潔,難懂,難以除錯,維

Python中lambda和in指用法小結

in的用法小結 列舉或遍歷 >>> for i in range(100): print(i) 0 1 2 3 4 5 6 7 判斷 if 1 in aa: print 'V

Java8中 Date和LocalDate的相互轉換

一.簡述 Date物件表示特定的日期和時間，而LocalDate(Java8)物件只包含沒有任何時間資訊的日期。 因此，如果我們只關心日期而不是時間資訊，則可以在Date和LocalDate之間進行轉換。 二.Date轉LocalDate 如果要將j