artificial-intelligence-codes-coding-247791.jpg

參考答案

這個問題考察的是對Linux命令的熟悉程度，以及對Java中集合操作的綜合運用，自從轉到Java 8以后，我就一直使用流來處理集合了，下面的代碼就是我用流來實現的參考答案

package org.java.learn.java8.stream;

import java.io.*;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;

public class ShellExample {

    public static void main(String[] args) throws IOException {
        //cat命令，相當于是讀取文件中的所有行，并輸出
        File file = new File("/Users/duqi/IdeaProjects/LearnJava/src/main/java/org/java/learn/java8/stream/t1.txt");
        BufferedReader bufferedReader = new BufferedReader(new FileReader(file));
        List<String> lines = new ArrayList<>();
        String str = null;
        while ((str = bufferedReader.readLine()) != null) {
            lines.add(str);
        }

        //grep a，相當于filter
        lines = lines.stream().filter(s -> s.contains("a")).collect(Collectors.toList());

        //sort 按照字典序從小到大排序
        lines = lines.stream().sorted().collect(Collectors.toList());

        //uniq -c，統計相同的元素的個數
        Map<String, Long> integerMap =
                lines.stream().sorted().collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));

        //sort -rn，排序后逆序輸出
        List<Long> res = integerMap.values().stream().sorted(Comparator.reverseOrder()).collect(Collectors.toList());

        res.forEach(System.out::println);
    }

}

知識點梳理

背景&基本概念

在以前，要操作一個集合，按照Java作為命令式語言的特點，開發者需要自己去關心集合的循環，每個循環里針對元素的操作（過濾、轉換、合并）等等，這些代碼寫起來很繁瑣，又容易出錯。

流（stream）是Java API的新成員，它允許開發者以聲明方式處理集合（類似于寫SQL），開發者只需要直接指明自己要做什么操作，而不需要關心對集合的迭代。使用流寫出來的代碼可讀性很好、表達能力很強，我目前在開發中，能使用流的地方一定會使用流，它幫助我減少了很多代碼行數。

流也需要對集合做迭代，只是JDK的開發者將迭代放在了API背后，稱為內部迭代，而集合的迭代則需要開發者自己維護，稱為外部迭代。使用內部迭代的好處，一方面開發者的代碼得以簡化，另一方面，流可以在內部對迭代進行種種優化，同時不影響開發者的業務代碼。

常見api

流的API分為兩種，中間操作和終端操作，中間操作產生的結果還是一個流，終端操作產生的結果可能是一個集合或者是一個數字，總之不是一個流。

stream.png

常見的流的操作有：篩選（filter）、切片（limit）、映射（map、flatMap）、查找（find）、匹配（match）和規約（reduce）；流不僅支持串行操作，還支持并行操作，使用并行流可以提高處理超大集合時候的性能。這里我整理了自己在工作中常用的流操作：

使用案例

假設有交易和交易員兩個概念——分別是下面的Trader和Transaction，現在有個交易列表，里面記錄了這些交易員在某些年份的交易。

交易員的定義

package stream;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Trader {
    private String name;
    private String city;
}

交易的定義

package stream;

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Transaction {
    private Trader trader;
    private int year;
    private int value;
}

上下文，有一個交易列表

package stream;

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

public class StreamExample {
    public static void main(String[] args) {
        Trader raoul = new Trader("Raoul", "Cambridge");
        Trader mario = new Trader("Mario", "Milan");
        Trader alan = new Trader("Alan", "Cambridge");
        Trader brian = new Trader("Brian", "Cambridge");

        List<Transaction> transactions = Arrays.asList(
            new Transaction(brian, 2011, 300),
            new Transaction(raoul, 2012, 1000),
            new Transaction(raoul, 2011, 400),
            new Transaction(mario, 2012, 710),
            new Transaction(mario, 2012, 700),
            new Transaction(alan, 2012, 950)
        );
    }
}

基于上述背景，讀者可以跟著我做下面的這些練習：

• 找出2011年所有的交易并按照交易額排序（從低到高）

List<Transaction> transactions2011 = transactions.stream()
    .filter(transaction -> transaction.getYear() == 2011) //過濾出所有2011年的交易
    .sorted(Comparator.comparing(Transaction::getValue))    //按照交易的金額排序
    .collect(Collectors.toList());  //將所有的結果整理成列表

• 交易員都在哪些不同的城市工作過

List<String> cities = transactions.stream()            
    .map(transaction -> transaction.getTrader().getCity())
    .distinct()
    .collect(Collectors.toList());

• 查找所有來自Cambridge的交易員，并按照姓名排序

List<Trader> traders = transactions.stream()
    .filter(transaction -> "Cambridge".equals(transaction.getTrader().getCity()))
    .map(Transaction::getTrader)
    .sorted(Comparator.comparing(Trader::getName))
    .collect(Collectors.toList());

• 將所有交易員的姓名按照字母順序排序，并連接成一個字符串返回

String nameStr = transactions.stream()
    .map(transaction -> transaction.getTrader().getName())
    .distinct()
    .sorted()
    .collect(Collectors.joining());

• 有沒有交易員是在Milan工作的？

boolean milanBased = transactions.stream()
    .anyMatch(transaction -> "Milan".equals(transaction.getTrader().getCity()));

• 打印所有城市在劍橋的交易員的交易額

transactions.stream()
    .filter(transaction -> "Cambridge".equals(transaction.getTrader().getCity()))
    .map(Transaction::getValue)
    .forEach(System.out::println);

• 所有交易中，最高的交易額是多少？

Optional<Integer> maxValue = transactions.stream()
    .map(Transaction::getValue)
    .reduce(Integer::max);

• 將所有的交易按照年份分組，存放在一個Map中

Map<Integer, Transaction> yearMap = transactions.stream()
    .collect(Collectors.toMap(Transaction::getYear, transaction -> transaction));

• 找到交易額最小的交易

Optional<Transaction> minTransaction = transactions.stream()
    .min(Comparator.comparing(Transaction::getValue));

參考資料

1. https://www.journaldev.com/2774/java-8-stream
2. 《Java 8實戰》
3. https://docs.oracle.com/javase/8/docs/api/java/util/stream/package-summary.html#package.description

本號專注于后端技術、JVM問題排查和優化、Java面試題、個人成長和自我管理等主題，為讀者提供一線開發者的工作和成長經驗，期待你能在這里有所收獲。

javaadu