024：用 Java 实现 shell 命令 cat 1.log | grep a | sort | uniq -c | sort -rn 的功能

参考答案

这个问题考察的是对 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 分为两种，中间操作和终端操作，中间操作产生的结果还是一个流，终端操作产生的结果可能是一个集合或者是一个数字，总之不是一个流。

常见的流的操作有：筛选（ filter ）、切片（ limit ）、映射（ map、flatMap ）、查找（ find ）、匹配（ match ）和规约（ reduce ）；流不仅支持串行操作，还支持并行操作，使用并行流可以提高处理超大集合时候的性能。这里我整理了自己在工作中常用的流操作：

| 操作 | 类型 | 返回类型 | 使用的类型 /函数式接口 | 函数描述符 | | :-------: | :--: | :---------: | :--------------------: | :------------: | | filter | 中间 | Stream<t> | Predicate<t> | T -> boolean | | distinct | 中间 | Stream<t> | | | | skip | 中间 | Stream<t> | long | | | limit | 中间 | Stream<t> | long | | | map | 中间 | Stream<r> | Function<T, R> | T -> R | | flatMap | 中间 | Stream<r> | Function<T, Stream<r>> | T -> Stream<r> | | sorted | 中间 | Stream<t> | Comparator<t> | (T, T) -> int | | anyMatch | 终端 | boolean | Predicate<t> | T -> boolean | | noneMatch | 终端 | boolean | Predicate<t> | T -> boolean | | allMatch | 终端 | boolean | Predicate<t> | T -> boolean | | findAny | 终端 | Optional<t> | | | | findFirst | 终端 | Optional<t> | | | | forEach | 终端 | void | Consumer<t> | T -> void | | collect | 终端 | R | Collector<T, A, R> | | | reduce | 终端 | Optional<t> | BinaryOperator<t> | (T, T) -> T | | count | 终端 | Optional<t> | | |</t></t></t></t></t></t></t></t></t></t></t></r></r></r></r></t></t></t></t></t>

使用案例

假设有交易和交易员两个概念分别是下面的 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.journalde.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 面试题、个人成长和自我管理等主题，为读者提供一线开发者的工作和成长经验，期待你能在这里有所收获。