标签: java-stream

我需要基于单个对象创建两个对象以进一步流式处理和处理.如何使用流来实现这一目标？

伪代码可能如下所示:

stream.stream().
    map(p -> new Object(p.getParam1()) <AND> new Object(p.getParam2()) ).
    collect(Collectors.toList());

我在Java 8下面有代码快照.

 List<Employee> employees = DataProvider.getEmployees();
 Set<Employee> set = employees.stream().filter(emp -> {
                System.out.println(emp.getName());
                return emp.getName().equals("Vishal");
            }).collect(Collectors.toSet());

我只是想知道Set它在使用时使用默认的哪个实现Collectors.toSet()(参见上面的例子)？

另外,有没有办法表明java API使用特定的实现(例如HashSet)？

有没有更好的方法来计算地图中所有列表的大小？那么firstList.size() + secondList.size()？我已经这样做了,但创建一个仅用于计数的列表并不是正确的方法..

public static void main(String[] args) {
    List<String> firstList = new ArrayList<>();
    firstList.add("first");
    List<String> secondList = new ArrayList<>();
    secondList.add("second");

    Map<String, List<String>> myMap = new HashMap<>();
    myMap.put("one", firstList);
    myMap.put("two", secondList);

    int size = myMap.entrySet().stream()
                               .map(entry -> entry.getValue())
                               .flatMap(list -> list.stream())
                               .collect(Collectors.toList())
                               .size();
    System.out.println("Size of all elements in map is:" + size);
}

我不能在不使用:: notation的情况下创建供应商.所有教程似乎都在使用::来获取方法.

Function<String, Object> beanFactory = m_context::getBean;
Function<Void, IRCPublic> ircPublicSupplier = a -> (IRCPublic) beanFactory.apply("developerPublicConnection");
ircPublicSupplier.apply(null);

我如何将第2行转换为单行语句来创建供应商,并且只需使用'.get()'.我可以使用'.apply(null)',但这看起来很脏.

谢谢!

假设我有一个

List<int[]> input = ( {1,2,3}, {1,2,4}, 
                {1,2,7}, {1,3,1}, {2,2}, 
                {1,2,8}, {1,3,4}, {2,3})

我需要把它转换成

Map<int[] , int[]> result = { [{1,2} -> {3,4,7,8}] ,
                    [{1,3} -> {1,4}] , 
                    [{2} -> {2,3}]   }

有效地,映射的关键是常见值,直到数组长度为2,值应包含所有这些数组的最后一个元素.

有人可以建议我如何使用java流来获取它,因为在正常的循环中,所有这些都是非常复杂的事情吗？

我想使用Java 8 Streams替换以下for-each循环:

for (Rule rule : this.rules) {

    if (rule.getCondition().evaluate(rule, record)) {
        Records.emit(collector, outputStreamMapping.get(rule.getOutputStream()), tuple, recordId, record);
        collector.ack(tuple);

        ruleApplied = true;
        break;
    }
}

if (!ruleApplied) {
    LOGGER.warn("No rule was applied to record {}", record);
    LOGGER.debug("Rules: {}", this.rules);
    ErrorReporter.emitErrorNode(this.collector, recordId, componentName,
            "No matching rule for record " + record, record);
    collector.fail(tuple);
}

我想迭代一组规则,并评估每个规则的条件.如果条件适用,我会对该记录采取行动并停止处理.如果没有应用规则,那么我想记录它并执行不同的记录处理.

不过,我不确定如何做到这一点.任何帮助和解释将不胜感激.

编辑:

我试过这个:

    this.rules.stream().filter(rule -> rule.getCondition().evaluate(rule, record)).forEach((rule) -> {
        Records.emit(collector, outputStreamMapping.get(rule.getOutputStream()), tuple, recordId, record);
        collector.ack(tuple);

        ruleApplied = true;
        break;
    });

当然,它不喜欢break语句,并且还抱怨ruleApplied不是最终的,因为它被声明在lambda的范围之外.

基于我所看到的答案,似乎循环是最干净的方式.我不确定是否有其他流构造允许我以与在基本循环中所做的不同的方式封装逻辑(即,中断和跟踪布尔).

EDIT2:

以下是基于此主题建议的解决方案: …

让我们假设我有一个对象:

class MyObject {
    private int id;
    private HashMap<Integer, OtherObject> otherObjects;
}

我想要做的是访问otherObjects列表的属性MyObject并将它们全部添加到a otherObjects list.

我可以使用.forEach和.addAll进入,otherObjects list但我正在尝试看看是否有可能使用lambdas来实现这一点.我想到了类似的东西,但它似乎不起作用:

myObjectList.stream()
    .map(o -> o.getOtherObjects())
    .map(oo -> oo.values())
    .collect(Collectors.toList());

但似乎与对象类型存在冲突.我猜这是因为我从一个对象流开始,最后得到一个列表流,它会混淆.我怎样才能做到这一点？更一般地说,如何将许多父对象的对象列表收集到一个列表中？

假设我们有一个算法在循环中顺序生成项目(每次迭代一个项目),我们希望将此算法放入一个返回这些项目流的方法中.

哪种方法最好; 这个？

Stream<Cell> streamCellsTouchingRay(Point2D fromPoint, Vector2D direction){
    // ...
    Stream<Cell> stream = Stream.of(/* 1st item */);
    while(/* ... */){
        // ...
        stream = Stream.concat(stream, /* i'th item */);
    }
}

......还是这个？

Stream<Cell> streamCellsTouchingRay(Point2D fromPoint, Vector2D direction){
    // ...
    ArrayList<Cell> cells = new ArrayList<>(/* required capacity is known */);
    cells.add(/* 1st item */);
    while(/* ... */){
        // ...
        cells.add(/* i'th item */);
    }
    return cells.stream();
}

......还是其他方法呢？

这可以通过Stream | Map完成,这样我就不需要将结果放在外部HashMap中,而是使用.collect(Collectors.toMap(...))收集结果; ？

Map<ReportType, Long> rep = new HashMap<>(); // result is here
Arrays.stream(rTypes).forEach(r -> rep.put(r.reportType, r.calcValue()));

在哪里r.calcValue()计算新结果,然后放在地图中.

我有一个人的域名

public class Person{
  String name;
}

我有一个列表的人名字符串,如

listRange = new ListWith("Bob","John","Mark");

我如何使用Java 8流在resultList中过滤,哪个人在此范围列表中具有名称.可能就像

resultList.stream().filter(p->p.getName().equals(listRange.any).collect();

如何使用Lambda过滤resultList？