跳到主要內容

還看不懂同事的代碼？超強的 Stream 流操作姿勢還不學習一下

Java 8 新特性系列文章索引。







前言


我們都知道 Lambda 和 Stream 是 Java 8 的兩大亮點功能，在前面的文章里已經介紹過 Lambda 相關知識，這次介紹下 Java 8 的 Stream 流操作。它完全不同於 java.io 包的 Input/Output Stream ，也不是大數據實時處理的 Stream 流。這個 Stream 流操作是 Java 8 對集合操作功能的增強，專註於對集合的各種高效、便利、優雅的聚合操作。藉助於 Lambda 表達式，顯著的提高編程效率和可讀性。且 Stream 提供了并行計算模式，可以簡潔的編寫出并行代碼，能充分發揮如今計算機的多核處理優勢。


在使用 Stream 流操作之前你應該先了解 Lambda 相關知識，如果還不了解，可以參考之前文章： 。


1. Stream 流介紹


Stream 不同於其他集合框架，它也不是某種數據結構，也不會保存數據，但是它負責相關計算，使用起來更像一個高級的迭代器。在之前的迭代器中，我們只能先遍歷然後在執行業務操作，而現在只需要指定執行什麼操作， Stream 就會隱式的遍歷然後做出想要的操作。另外 Stream 和迭代器一樣的只能單向處理，如同奔騰長江之水一去而不復返。


由於 Stream 流提供了惰性計算和并行處理的能力，在使用并行計算方式時數據會被自動分解成多段然後并行處理，最後將結果匯總。所以 Stream 操作可以讓程序運行變得更加高效。


2. Stream 流概念


Stream 流的使用總是按照一定的步驟進行，可以抽象出下面的使用流程。



數據源（source） -> 數據處理/轉換（intermedia） -> 結果處理（terminal ）



2.1. 數據源


數據源（source）也就是數據的來源，可以通過多種方式獲得 Stream 數據源，下面列舉幾種常見的獲取方式。



  • Collection.stream(); 從集合獲取流。

  • Collection.parallelStream(); 從集合獲取并行流。

  • Arrays.stream(T array) or Stream.of(); 從數組獲取流。

  • BufferedReader.lines(); 從輸入流中獲取流。

  • IntStream.of() ; 從靜態方法中獲取流。

  • Stream.generate(); 自己生成流


2.2. 數據處理


數據處理/轉換（intermedia）步驟可以有多個操作，這步也被稱為intermedia（中間操作）。在這個步驟中不管怎樣操作，它返回的都是一個新的流對象，原始數據不會發生任何改變，而且這個步驟是惰性計算處理的，也就是說只調用方法並不會開始處理，只有在真正的開始收集結果時，中間操作才會生效，而且如果遍歷沒有完成，想要的結果已經獲取到了（比如獲取第一個值），會停止遍歷，然後返回結果。惰性計算可以顯著提高運行效率。


數據處理演示。


@Test
 public void streamDemo(){
     List<String> nameList = Arrays.asList("Darcy", "Chris", "Linda", "Sid", "Kim", "Jack", "Poul", "Peter");
     // 1. 篩選出名字長度為4的
     // 2. 名字前面拼接 This is
     // 3. 遍歷輸出
     nameList.stream()
             .filter(name -> name.length() == 4)
             .map(name -> "This is "+name)
             .forEach(name -> System.out.println(name));
 }
 // 輸出結果
 // This is Jack
 // This is Poul

數據處理/轉換操作自然不止是上面演示的過濾 filter 和 map映射兩種，另外還有 map (mapToInt, flatMap 等)、 filter、 distinct、 sorted、 peek、 limit、 skip、 parallel、 sequential、 unordered 等。


2.3. 收集結果


結果處理（terminal ）是流處理的最後一步，執行完這一步之後流會被徹底用盡，流也不能繼續操作了。也只有到了這個操作的時候，流的數據處理/轉換等中間過程才會開始計算，也就是上面所說的惰性計算。結果處理也必定是流操作的最後一步。


常見的結果處理操作有 forEach、 forEachOrdered、 toArray、 reduce、 collect、 min、 max、 count、 anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 iterator 等。


下面演示了簡單的結果處理的例子。


/**
  * 轉換成為大寫然後收集結果，遍歷輸出
  */
 @Test
 public void toUpperCaseDemo() {
     List<String> nameList = Arrays.asList("Darcy", "Chris", "Linda", "Sid", "Kim", "Jack", "Poul", "Peter");
     List<String> upperCaseNameList = nameList.stream()
             .map(String::toUpperCase)
             .collect(Collectors.toList());
     upperCaseNameList.forEach(name -> System.out.println(name + ","));
 }
 // 輸出結果
 // DARCY,CHRIS,LINDA,SID,KIM,JACK,POUL,PETER,

2.4. short-circuiting


有一種 Stream 操作被稱作 short-circuiting ，它是指當 Stream 流無限大但是需要返回的 Stream 流是有限的時候，而又希望它能在有限的時間內計算出結果，那麼這個操作就被稱為short-circuiting。例如　findFirst　操作。


3. Stream 流使用


Stream 流在使用時候總是藉助於 Lambda 表達式進行操作，Stream 流的操作也有很多種方式，下面列舉的是常用的 11 種操作。


3.1. Stream 流獲取


獲取 Stream 的幾種方式在上面的 Stream 數據源里已經介紹過了，下面是針對上面介紹的幾種獲取 Stream 流的使用示例。


@Test
 public void createStream() throws FileNotFoundException {
     List<String> nameList = Arrays.asList("Darcy", "Chris", "Linda", "Sid", "Kim", "Jack", "Poul", "Peter");
     String[] nameArr = {"Darcy", "Chris", "Linda", "Sid", "Kim", "Jack", "Poul", "Peter"};
     // 集合獲取 Stream 流
     Stream<String> nameListStream = nameList.stream();
     // 集合獲取并行 Stream 流
     Stream<String> nameListStream2 = nameList.parallelStream();
     // 數組獲取 Stream 流
     Stream<String> nameArrStream = Stream.of(nameArr);
     // 數組獲取 Stream 流
     Stream<String> nameArrStream1 = Arrays.stream(nameArr);
     // 文件流獲取 Stream 流
     BufferedReader bufferedReader = new BufferedReader(new FileReader("README.md"));
     Stream<String> linesStream = bufferedReader.lines();
     // 從靜態方法獲取流操作
     IntStream rangeStream = IntStream.range(1, 10);
     rangeStream.limit(10).forEach(num -> System.out.print(num+","));
     System.out.println();
     IntStream intStream = IntStream.of(1, 2, 3, 3, 4);
     intStream.forEach(num -> System.out.print(num+","));
 }

3.2. forEach


forEach 是 Strean 流中的一個重要方法，用於遍歷 Stream 流，它支持傳入一個標準的 Lambda 表達式。但是它的遍歷不能通過 return/break 進行終止。同時它也是一個 terminal 操作，執行之後 Stream 流中的數據會被消費掉。


如輸出對象。


List<Integer> numberList = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
 numberList.stream().forEach(number -> System.out.println(number+","));
 // 輸出結果
 // 1,2,3,4,5,6,7,8,9,

3.3. map / flatMap


使用 map 把對象一對一映射成另一種對象或者形式。


/**
  * 把数字值乘以2
  */
 @Test
 public void mapTest() {
     List<Integer> numberList = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
     // 映射成 2倍数字
     List<Integer> collect = numberList.stream()
             .map(number -> number * 2)
             .collect(Collectors.toList());
     collect.forEach(number -> System.out.print(number + ","));
     System.out.println();
 
     numberList.stream()
             .map(number -> "数字 " + number + ",")
             .forEach(number -> System.out.println(number));
 }
 // 輸出結果
 // 2,4,6,8,10,12,14,16,18,
 // 数字 1,数字 2,数字 3,数字 4,数字 5,数字 6,数字 7,数字 8,数字 9,

上面的 map 可以把數據進行一對一的映射，而有些時候關係可能不止 1對 1那麼簡單，可能會有1對多。這時可以使用 flatMap。下面演示使用 flatMap把對象扁平化展開。


/**
  * flatmap把對象扁平化
  */
 @Test
 public void flatMapTest() {
     Stream<List<Integer>> inputStream = Stream.of(
             Arrays.asList(1),
             Arrays.asList(2, 3),
             Arrays.asList(4, 5, 6)
     );
     List<Integer> collect = inputStream
             .flatMap((childList) -> childList.stream())
             .collect(Collectors.toList());
     collect.forEach(number -> System.out.print(number + ","));
 }
 // 輸出結果
 // 1,2,3,4,5,6,

3.4. filter


使用 filter 進行數據篩選，挑選出想要的元素，下面的例子演示怎麼挑選出偶數数字。


/**
  * filter 數據篩選
  * 篩選出偶數数字
  */
 @Test
 public void filterTest() {
     List<Integer> numberList = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
     List<Integer> collect = numberList.stream()
             .filter(number -> number % 2 == 0)
             .collect(Collectors.toList());
     collect.forEach(number -> System.out.print(number + ","));
 }

得到如下結果。


2,4,6,8,

3.5. findFirst


findFirst 可以查找出 Stream 流中的第一個元素，它返回的是一個 Optional 類型，如果還不知道 Optional 類的用處，可以參考之前文章 。


/**
  * 查找第一個數據
  * 返回的是一個 Optional 對象
  */
 @Test
 public void findFirstTest(){
     List<Integer> numberList = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
     Optional<Integer> firstNumber = numberList.stream()
             .findFirst();
     System.out.println(firstNumber.orElse(-1));
 }
 // 輸出結果
 // 1

findFirst 方法在查找到需要的數據之後就會返回不再遍歷數據了，也因此 findFirst 方法可以對有無限數據的 Stream 流進行操作，也可以說 findFirst 是一個 short-circuiting 操作。


3.6. collect / toArray


Stream 流可以輕鬆的轉換為其他結構，下面是幾種常見的示例。


 /**
  * Stream 轉換為其他數據結構
  */
 @Test
 public void collectTest() {
     List<Integer> numberList = Arrays.asList(1, 1, 2, 2, 3, 3, 4, 4, 5);
     // to array
     Integer[] toArray = numberList.stream()
             .toArray(Integer[]::new);
     // to List
     List<Integer> integerList = numberList.stream()
             .collect(Collectors.toList());
     // to set
     Set<Integer> integerSet = numberList.stream()
             .collect(Collectors.toSet());
     System.out.println(integerSet);
     // to string
     String toString = numberList.stream()
             .map(number -> String.valueOf(number))
             .collect(Collectors.joining()).toString();
     System.out.println(toString);
     // to string split by ,
     String toStringbJoin = numberList.stream()
             .map(number -> String.valueOf(number))
             .collect(Collectors.joining(",")).toString();
     System.out.println(toStringbJoin);
 }
 // 輸出結果
 // [1, 2, 3, 4, 5]
 // 112233445
 // 1,1,2,2,3,3,4,4,5

3.7. limit / skip


獲取或者扔掉前 n 個元素


/**
  * 獲取 / 扔掉前 n 個元素
  */
 @Test
 public void limitOrSkipTest() {
     // 生成自己的隨機數流
     List<Integer> ageList = Arrays.asList(11, 22, 13, 14, 25, 26);
     ageList.stream()
             .limit(3)
             .forEach(age -> System.out.print(age+","));
     System.out.println();
     
     ageList.stream()
             .skip(3)
             .forEach(age -> System.out.print(age+","));
 }
 // 輸出結果
 // 11,22,13,
 // 14,25,26,

3.8. Statistics


數學統計功能，求一組數組的最大值、最小值、個數、數據和、平均數等。


/**
  * 數學計算測試
  */
 @Test
 public void mathTest() {
     List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6);
     IntSummaryStatistics stats = list.stream().mapToInt(x -> x).summaryStatistics();
     System.out.println("最小值：" + stats.getMin());
     System.out.println("最大值：" + stats.getMax());
     System.out.println("個數：" + stats.getCount());
     System.out.println("和：" + stats.getSum());
     System.out.println("平均數：" + stats.getAverage());
 }
 // 輸出結果
 // 最小值：1
 // 最大值：6
 // 個數：6
 // 和：21
 // 平均數：3.5

3.9. groupingBy


分組聚合功能，和數據庫的 Group by 的功能一致。


/**
  * groupingBy
  * 按年齡分組
  */
 @Test
 public void groupByTest() {
     List<Integer> ageList = Arrays.asList(11, 22, 13, 14, 25, 26);
     Map<String, List<Integer>> ageGrouyByMap = ageList.stream()            
         .collect(Collectors.groupingBy(age -> String.valueOf(age / 10)));
     ageGrouyByMap.forEach((k, v) -> {
         System.out.println("年齡" + k + "0多歲的有：" + v);
     });
 }
 // 輸出結果
 // 年齡10多歲的有：[11, 13, 14]
 // 年齡20多歲的有：[22, 25, 26]

3.10. partitioningBy


/**
  * partitioningBy
  * 按某個條件分組
  * 給一組年齡，分出成年人和未成年人
  */
 public void partitioningByTest() {
     List<Integer> ageList = Arrays.asList(11, 22, 13, 14, 25, 26);
     Map<Boolean, List<Integer>> ageMap = ageList.stream()
             .collect(Collectors.partitioningBy(age -> age > 18));
     System.out.println("未成年人：" + ageMap.get(false));
     System.out.println("成年人：" + ageMap.get(true));
 }
 // 輸出結果
 // 未成年人：[11, 13, 14]
 // 成年人：[22, 25, 26]

3.11. 進階 - 自己生成 Stream 流


/**
  * 生成自己的 Stream 流
  */
 @Test
 public void generateTest(){
     // 生成自己的隨機數流
     Random random = new Random();
     Stream<Integer> generateRandom = Stream.generate(random::nextInt);
     generateRandom.limit(5).forEach(System.out::println);
     // 生成自己的 UUID 流
     Stream<UUID> generate = Stream.generate(UUID::randomUUID);
     generate.limit(5).forEach(System.out::println);
 }
 
 // 輸出結果
 // 793776932
 // -2051545609
 // -917435897
 // 298077102
 // -1626306315
 // 31277974-841a-4ad0-a809-80ae105228bd
 // f14918aa-2f94-4774-afcf-fba08250674c
 // d86ccefe-1cd2-4eb4-bb0c-74858f2a7864
 // 4905724b-1df5-48f4-9948-fa9c64c7e1c9
 // 3af2a07f-0855-455f-a339-6e890e533ab3

上面的例子中 Stream 流是無限的，但是獲取到的結果是有限的，使用了 Limit 限制獲取的數量，所以這個操作也是 short-circuiting 操作。


4. Stream 流優點


4.1. 簡潔優雅


正確使用並且正確格式化的 Stream 流操作代碼不僅簡潔優雅，更讓人賞心悅目。下面對比下在使用 Stream 流和不使用 Stream 流時相同操作的編碼風格。


/**
  * 使用流操作和不使用流操作的編碼風格對比
  */
 @Test
 public void diffTest() {
     // 不使用流操作
     List<String> names = Arrays.asList("Jack", "Jill", "Nate", "Kara", "Kim", "Jullie", "Paul", "Peter");
     // 篩選出長度為4的名字
     List<String> subList = new ArrayList<>();
     for (String name : names) {
         if (name.length() == 4) {
             subList.add(name);
         }
     }
     // 把值用逗號分隔
     StringBuilder sbNames = new StringBuilder();
     for (int i = 0; i < subList.size() - 1; i++) {
         sbNames.append(subList.get(i));
         sbNames.append(", ");
     }
     // 去掉最後一個逗號
     if (subList.size() > 1) {
         sbNames.append(subList.get(subList.size() - 1));
     }
     System.out.println(sbNames);
 }
 // 輸出結果
 // Jack, Jill, Nate, Kara, Paul

如果是使用 Stream 流操作。


// 使用 Stream 流操作
 String nameString = names.stream()
        .filter(num -> num.length() == 4)
        .collect(Collectors.joining(", "));
 System.out.println(nameString);

4.2. 惰性計算


上面有提到，數據處理/轉換（intermedia） 操作 map (mapToInt, flatMap 等)、 filter、 distinct、 sorted、 peek、 limit、 skip、 parallel、 sequential、 unordered 等這些操作，在調用方法時並不會立即調用，而是在真正使用的時候才會生效，這樣可以讓操作延遲到真正需要使用的時刻。


下面會舉個例子演示這一點。


 /**
   * 找出偶數
   */
  @Test
  public void lazyTest() {
      // 生成自己的隨機數流
      List<Integer> numberLIst = Arrays.asList(1, 2, 3, 4, 5, 6);
      // 找出偶數
      Stream<Integer> integerStream = numberLIst.stream()
              .filter(number -> {
                  int temp = number % 2;
                  if (temp == 0 ){
                      System.out.println(number);
                  }
                  return temp == 0;
              });
 
      System.out.println("分割線");
      List<Integer> collect = integerStream.collect(Collectors.toList());
  }

如果沒有 惰性計算，那麼很明顯會先輸出偶數，然後輸出 分割線。而實際的效果是。


分割線
 2
 4
 6

可見 惰性計算 把計算延遲到了真正需要的時候。


4.3. 并行計算


獲取 Stream 流時可以使用 parallelStream 方法代替 stream 方法以獲取并行處理流，并行處理可以充分的發揮多核優勢，而且不增加編碼的複雜性。


下面的代碼演示了生成一千萬個隨機數后，把每個隨機數乘以2然後求和時，串行計算和并行計算的耗時差異。


  /**
   * 并行計算
   */
  @Test
  public void main() {
      // 生成自己的隨機數流，取一千萬個隨機數
      Random random = new Random();
      Stream<Integer> generateRandom = Stream.generate(random::nextInt);
      List<Integer> numberList = generateRandom.limit(10000000).collect(Collectors.toList());
 
      // 串行 - 把一千萬個隨機數，每個隨機數 * 2 ，然後求和
      long start = System.currentTimeMillis();
      int sum = numberList.stream()
          .map(number -> number * 2)
          .mapToInt(x -> x)
          .sum();
      long end = System.currentTimeMillis();
      System.out.println("串行耗時："+(end - start)+"ms，和是:"+sum);
 
      // 并行 - 把一千萬個隨機數，每個隨機數 * 2 ，然後求和
      start = System.currentTimeMillis();
      sum = numberList.parallelStream()
          .map(number -> number * 2)
          .mapToInt(x -> x)
          .sum();
      end = System.currentTimeMillis();
      System.out.println("并行耗時："+(end - start)+"ms，和是:"+sum);
  }

得到如下輸出。


串行耗時：1005ms，和是:481385106
 并行耗時：47ms，和是:481385106

效果顯而易見，代碼簡潔優雅。


5. Stream 流建議


5.1 保證正確排版


從上面的使用案例中，可以發現使用 Stream 流操作的代碼非常簡潔，而且可讀性更高。但是如果不正確的排版，那麼看起來將會很糟糕，比如下面的同樣功能的代碼例子，多幾層操作呢，是不是有些讓人頭大？


// 不排版
 String string = names.stream().filter(num -> num.length() == 4).map(name -> name.toUpperCase()).collect(Collectors.joining(","));
 // 排版
 String string = names.stream()
         .filter(num -> num.length() == 4)
         .map(name -> name.toUpperCase())
         .collect(Collectors.joining(","));

5.1 保證函數純度


如果想要你的 Stream 流對於每次的相同操作的結果都是相同的話，那麼你必須保證 Lambda 表達式的純度，也就是下面亮點。



  • Lambda 中不會更改任何元素。

  • Lambda 中不依賴於任何可能更改的元素。


這兩點對於保證函數的冪等非常重要，不然你程序執行結果可能會變得難以預測，就像下面的例子。


@Test
 public void simpleTest(){
     List<Integer> numbers = Arrays.asList(1, 2, 3);
     int[] factor = new int[] { 2 };
     Stream<Integer> stream = numbers.stream()
             .map(e -> e * factor[0]);
     factor[0] = 0;
     stream.forEach(System.out::println);
 }
 // 輸出結果
 // 0
 // 0
 // 0

文中代碼都已經上傳到


。



個人網站：
如果你喜歡這篇文章，可以關注公眾號，一起成長。
關注公眾號回復資源可以沒有套路的獲取全網最火的的 Java 核心知識整理&面試資料。

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※想知道網站建置、網站改版該如何進行嗎?將由專業工程師為您規劃客製化網頁設計及後台網頁設計



※不管是台北網頁設計公司、台中網頁設計公司，全省皆有專員為您服務



※Google地圖已可更新顯示潭子電動車充電站設置地點!!



※帶您來看台北網站建置，台北網頁設計，各種案例分享


Orignal From: 還看不懂同事的代碼？超強的 Stream 流操作姿勢還不學習一下

留言

張貼留言

這個網誌中的熱門文章

Python 併發總結，多線程，多進程，異步IO

1 測量函數運行時間 import time def profile(func): def wrapper(*args, ** kwargs): import time start = time.time() func( *args, ** kwargs) end = time.time() print ' COST: {} ' .format(end - start) return wrapper @profile def fib(n): if n<= 2 : return 1 return fib(n-1) + fib(n-2 ) fib( 35 )   2 啟動多個線程，並等待完成   2.1 使用threading.enumerate() import threading for i in range(2 ): t = threading.Thread(target=fib, args=(35 ,)) t.start() main_thread = threading.currentThread() for t in threading.enumerate(): if t is main_thread: continue t.join()   2.2 先保存啟動的線程 threads = [] for i in range(5 ): t = Thread(target=foo, args= (i,)) threads.append(t) t.start() for t in threads: t.join()   3 使用信號量，限制同時能有幾個線程訪問臨界區 from threading import Semaphore import time sema = Semaphor...
張貼留言
閱讀完整內容

韋伯連續劇終於更新 期待第一季順利完結

　　地球天文學界的跳票大王詹姆斯·韋伯空間望遠鏡 (James Webb Space Telescope，縮寫為 JWST)自 1996 年以來斷斷續續不按劇本演出的連續劇終於讓焦慮的觀眾們又等到了一次更新：五層遮陽罩測試順利完成。 裝配完成的韋伯望遠鏡與好夥伴遮陽罩同框啦。Credit: NASA 　　嚴格的測試是任何空間任務順利成功的重中之重。遮陽罩，這個韋伯望遠鏡異常重要的親密夥伴，要是無法正常運轉的話，韋伯的這一季天文界連續劇說不準就要一直拖更了。 　　詹姆斯·韋伯空間望遠鏡是歷史上造出的最先進的空間望遠鏡。它不僅是一架紅外望遠鏡，還具有特別高的靈敏度。但想要達到辣么高的靈敏度來研究系外行星和遙遠的宇宙童年，韋伯童鞋必須非常"冷靜"，體溫升高的話，靈敏度會大大折損。這個時候，遮陽罩就要大顯身手啦。 　　遮陽罩在韋伯的設計中至關重要。韋伯望遠鏡會被發射到拉格朗日 L2 點，運行軌道很高，遠離太陽、地球與月球。太陽是韋伯的主要熱量干擾的來源，其次是地球與月球。遮陽罩會有效阻斷來自這三大熱源的能量並保護韋伯維持在工作溫度正常運轉。這個工作溫度指的是零下 220 攝氏度(-370 華氏度；50 開爾文)。 上圖中我們可以看出，韋伯望遠鏡的配置大致可分為兩部分：紅色較熱的一面溫度為 85 攝氏度，藍色較冷的一面溫度達到零下 233 攝氏度。紅色的這部分中，儀器包括太陽能板、通信設備、計算機、以及轉向裝置。藍色部分的主要裝置包括鏡面、探測器、濾光片等。Credit: STSci. 　　遮陽罩的那一部分和望遠鏡的鏡面這部分可以產生非常極端的溫差。遮陽的這面溫度可以達到 110 攝氏度，足以煮熟雞蛋，而背陰處的部分溫度極低，足以凍結氧氣。 　　工程師們剛剛完成了五層遮陽罩的測試，按照韋伯在 L2 時的運行狀態安裝了遮陽罩。L2 距離地球約 160 萬公里。NASA 表示這些測試使用了航天器的自帶系統來展開遮陽罩，測試目前都已成功完成。韋伯望遠鏡遮陽罩負責人 James Cooper 介紹說這是遮陽罩"第一次在望遠鏡系統的电子設備的控制下展開。儘管這個任務非常艱巨，難度高，但測試順利完成，遮陽罩展開時的狀態非常驚艷"。 　　遮陽罩由五層 Kapton 製成。Kapton 是一種聚酰亞胺薄膜材料， 耐高溫絕...
張貼留言
閱讀完整內容

LINE 發票管家「一鍵分享發票」新功能，聚餐AA更好算帳

» » LINE 發票管家「一鍵分享發票」新功能，聚餐AA更好算帳 消費明細好清楚，不怕算錯錢啦！ by in , 讀取中... 之前介紹過的「LINE 發票管家」，除了能對統一發票、管理消費紀錄，現在還能分享消費明細給其他朋友囉！趕快來看看該如何分享吧！讓大家在聚餐過後，不用再截圖、拍照把消費明細記錄下來分享到 LINE 好友群組，只要用 LINE發票管家就可以隨時一鍵分享消費明細，包括店家、消費時間、消費項目、金額通通都有，聚餐 AA 也更好算帳。 LINE 發票管家「一鍵分享發票」新功能，聚餐AA更好算帳 朋友聚餐完，經常會先由其中一位買單再事後收帳，不過難免擔心忘記拍照紀錄下消費明細，導致算帳變得很麻煩。但是，現在只要用 LINE發票管家，不僅能將發票存入載具後直接匯入發票，進而更方便管理每月的消費情況，現在還能用它來分享消費明細到 LINE 聊天室，不需要截圖，整個流程超級簡單！ ▲圖片來源： 當使用 LINE發票管家並且綁定載具後，只要日常消費有將發票存入載具就通通會自動匯入 LINE發票管家。如果想暸解自己近期的消費情況，也能在 LINE發票管家點選「發票明細」查詢所有消費紀錄。 ＊小提醒：存入手機條碼的發票，待財政部 1-2 日作業時間將發票資料匯入後， 打開單筆消費後分享到指定對象或群組。 像是朋友聚餐或其它購物消費，就能在 LINE發票管家查看每一筆消費的所有消費明細，每一項餐點的項目、價格通通一目了然。如果想將該筆消費內容分享給好友收帳，只要點選該筆消費明細後，接著點選畫面右上角的「分享」按鈕。 網頁設計 最專業,超強功能平台可客製,窩窩以「數位行銷」「品牌經營」「網站與應用程式」「印刷品設計」等四大主軸，為每一位客戶客製建立行銷脈絡及洞燭市場先機,請問 台中電動車 哪裡在賣比較便宜可以到台中景泰電動車門市去看看總店：臺中市潭子區潭秀里雅潭路一段102-1號。 電動車補助 推薦評價好的 iphone維修 中心擁有專業的維修技術團隊，同時聘請資深iphone手機維修專家，現場說明手機問題，快速修理，沒修好不收錢住家的頂樓裝 太陽光電 聽說可發揮隔熱功效一線推薦東陽能源擁有核心技術、...
張貼留言
閱讀完整內容