标签: java-stream

我经常需要根据产生double或int值的标准的最大化来收集集合的最大元素.Streams有max()函数,需要我实现一个比较器,我觉得很麻烦.是否有更简洁的语法,例如names.stream().argmax(String::length)在以下示例中？

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

public class ArgMax
{
    public static void main(String[] args)
    {
        List<String> names = Arrays.asList("John","Joe","Marilyn");
        String longestName = names.stream().max((String s,String t)->(Integer.compare(s.length(),t.length()))).get();
        System.out.println(longestName);
    }
}

我一直在阅读Java 8 Streams以及从数据源流式传输数据的方式,而不是让整个集合从中提取数据.

特别是我引用了一篇关于Java 8中的流的文章.

"没有存储.流没有值存储;它们通过一系列计算步骤从源(可能是数据结构,生成函数,I/O通道等)传输值." 来自:http: //www.drdobbs.com/jvm/lambdas-and-streams-in-java-8-libraries/240166818？pgno = 1

我理解从一个源一步一步地流式传输数据的概念.我不明白的是,如果你是从一个集合流式传输,怎么没有存储？该集合已存在于Heap中,您只是从该集合中流式传输数据,该集合已存在于"存储"中.

如果我只是使用标准for循环遍历集合,那么内存占用的区别是什么？

我正在尝试学习如何在我的日常编程中使用Java 8功能(例如lambdas和流),因为它使代码更清晰.

以下是我目前正在处理的内容:我从本地文件中获取一个字符串流,其中包含一些数据,稍后我将这些数据转换为对象.输入文件结构如下所示:

Airport name; Country; Continent; some number;

我的代码看起来像这样:

public class AirportConsumer implements AirportAPI {

List<Airport> airports = new ArrayList<Airport>();

@Override
public Stream<Airport> getAirports() {
    Stream<String> stream = null;
    try {
        stream = Files.lines(Paths.get("resources/planes.txt"));
        stream.forEach(line -> createAirport(line));

    } catch (IOException e) {
        e.printStackTrace();
    }
    return airports.stream();
}

public void createAirport(String line) {
    String airport, country, continent;
    int length;


    airport = line.substring(0, line.indexOf(';')).trim();
    line = line.replace(airport + ";", "");
    country = line.substring(0,line.indexOf(';')).trim();
    line = line.replace(country + ";", "");
    continent = …

我正在使用一个简单的循环构建一个对象:

WebTarget target = getClient().target(u);

for (Entry<String, String> queryParam : queryParams.entrySet()) {
    target = target.queryParam(queryParam.getKey(), queryParam.getValue());
}

我想使用Java8 Stream API做同样的事情,但我无法弄清楚如何做到这一点.让我挣扎的是每次都重新分配目标,所以简单的.forEach()将不起作用.我想我需要使用.collect()或reduce(),因为我正在寻找单个返回值,但此刻我迷路了!

我有以下课程:

public class Item {
    int id;
    String name;
    // few other fields, contructor, getters and setters
}

我有一个项目清单.我想迭代列表并找到具有特定id的实例.我正试图通过溪流来做.

public void foobar() {

    List<Item> items = getItemList();
    List<Integer> ids = getIdsToLookup();
    int id, i = ids.size() - 1;

    while (i >= 0) {
        id = ids.get(i);
        Optional<Item> item = items
            .stream()
            .filter(a -> a.getId() == id)
            .findFirst();
        // do stuff
        i--;
    }
}

这是迭代列表并获得我需要的元素的最佳方法吗？另外,我在id的过滤行上得到一个错误,它表示lambda表达式中使用的变量必须是final或者有效的final.也许我可以在while循环中定义id,这应该摆脱异常.谢谢.

我正在寻找一种聪明的方法来执行以下操作:

列出一个数字列表:

1,2,3,4,5,12,13,14,19

并将其压缩成一个字符串,如下所示:

1-5,12-14,19

使用以下规则:当范围中的数字计数为3或更多时,仅压缩到范围(即使用破折号).

即:1,2,4,5将导致:1,2,4,5和NOT:1-2,4-5

我一直在玩Java中新的和闪亮的功能部分,其中一个让我最困惑的事情是流？

它们的用途是什么？

在谷歌上,我主要找到了如何使用它们的解释和实际例子,我已经说过,没有具体的幕后魔术,这是我感兴趣的.

我不是指在实际意义上,来自一些函数式语言我想出了map/filter/reduce/etc. 相当快,但为什么我们需要先转换为流？Java已经有了迭代器.流和迭代器之间是否存在根本区别,例如一个是懒惰而另一个不是？或者是别的什么？

底线:迭代器和流之间的根本区别是什么,哪些功能无法实现为迭代器的扩展,需要一个全新的类型系列？

所以情况就是这样:我需要在某些日期登记人们的投票.简而言之,提出了一个日期,人们投票支持他们想要的日期.

数据结构如下:

private HashMap<LocalDateTime, Set<Vote>> votes;

投票是:

public class Vote {
    private String name;
    private VoteType vote;

    public Vote(String name, VoteType vote) {
        super();
        this.name = name;
        this.vote = vote;
    }
}

其中VoteType只是一个枚举:

public enum VoteType {YES, NO, MAYBE}

现在我已经创建了一个返回可用性投票数量的流(VoteType):

public Map<LocalDateTime, Integer> voteCount(VoteType targetVote) {
    return this.votes.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new Integer(
            e.getValue().stream().filter(v -> v.getVote() == targetVote).collect(Collectors.toList()).size())));
}

所以我的问题是:如何使用Java Streams获得最多"YES"的日期.

/* Returns the date that got the most 'YES' votes */
public LocalDateTime winningDate() {
    // TODO
}

感谢您的帮助!

请原谅我,如果解决方案非常明显,但我似乎无法弄清楚如何做到这一点

public static void main(String[] args) {
    Map<String, String> map = new HashMap<>();
    map.put("b1", "a1");
    map.put("b2", "a2");
    map.put("b3", "a1");
    Map<String, List<String>> mm = map.values().stream().collect(Collectors.groupingBy(m -> m));
    System.out.println(mm);
}

我想根据hashmap中的值进行分组.我想要输出,{a1=[b1, b3], a2=[b2]}但它现在正在出现{a1=[a1, a1], a2=[a2]}

我对溪流很新,所以请帮帮我(并且温柔).

我想做的是以下内容.我有一个BufferedReader从一个文件读取,其中每行看起来像这样:"a,b".例如:

示例输入文件

"a,b"

"d,e"

"f,g"

我想将其转换为LinkedList<String[]>:

例 LinkedList<String[]>

[{"a","b"},{"c","d"},{"f","g"}]

你会如何使用流方法？

这是我试过的:

List numbers = reader.lines().map(s -> s.split("[\\W]")).collect(Collectors.toList());

这不起作用.我的IDE提供以下反馈:

Incompatible types. Required List but 'collect' was inferred to R: no instance(s) of type variable(s) T exist so that List<T> conforms to List

它显示......我仍在努力想出流.