首页
学习
活动
专区
工具
TVP
发布
社区首页 >专栏 >优雅实现 Shell 命令的 Java 流特性

优雅实现 Shell 命令的 Java 流特性

作者头像
用户2781897
发布2019-06-14 15:04:05
7410
发布2019-06-14 15:04:05
举报
文章被收录于专栏:服务端思维服务端思维
阿杜 | 作者

授权转载自「javaadu」公众号

如何通过 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

Predicate

T -> boolean

distinct

中间

Stream

skip

中间

Stream

long

limit

中间

Stream

long

map

中间

Stream

Function<T, R>

T -> R

flatMap

中间

Stream

Function<T, Stream>

T -> Stream

sorted

中间

Stream

Comparator

(T, T) -> int

anyMatch

终端

boolean

Predicate

T -> boolean

noneMatch

终端

boolean

Predicate

T -> boolean

allMatch

终端

boolean

Predicate

T -> boolean

findAny

终端

Optional

findFirst

终端

Optional

forEach

终端

void

Consumer

T -> void

collect

终端

R

Collector<T, A, R>

reduce

终端

Optional

BinaryOperator

(T, T) -> T

count

终端

Optional

使用案例

假设有交易和交易员两个概念——分别是下面的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));
本文参与 腾讯云自媒体分享计划,分享自微信公众号。
原始发表:2019-06-10,如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 服务端思维 微信公众号,前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体分享计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
0 条评论
热度
最新
推荐阅读
目录
  • 背景&基本概念
  • 常见api
  • 使用案例
    • 假设有交易和交易员两个概念——分别是下面的Trader和Transaction,现在有个交易列表,里面记录了这些交易员在某些年份的交易。首先,看交易员的定义
      • 然后,看交易的定义
      • 上下文,有一个交易列表
领券
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档