标签: java-stream

我有一个List<Foo>并且想要一个番石榴Multimap<String, Foo>,我们Foo按照它们的Collection<String> getTags()功能的每个标签对它们进行分组.

我正在使用java 8,所以lambdas和方法引用很好/鼓励.

例如,如果我有:

foo1, tags=a,b,c
foo2, tags=c,d
foo3, tags=a,c,e

我会得到一个Multimap<String, Foo>:

a -> foo1, foo3
b -> foo1
c -> foo1, foo2, foo3
d -> foo2
e -> foo3

基本上我寻找一种避免使用的方法

entry -> entry.getValue

和

entry -> entry.getKey

类似于什么Map.forEach().

如果我能找到一种工作方式map.stream().filter((k,v) -> )......等等

看起来这个界面叫做BiConsumer.或许转换为BiConsumer转换器或Stream.generate()

在单元测试中,我想验证两个列表包含相同的元素.要测试的列表是Person对象列表的构建,其中String提取了一个类型的字段.另一个列表包含String文字.

人们经常会找到以下代码片段来完成此任务(请参阅此答案):

List<Person> people = getPeopleFromDatabasePseudoMethod();
List<String> expectedValues = Arrays.asList("john", "joe", "bill");

assertTrue(people.stream().map(person -> person.getName()).collect(Collectors.toList()).containsAll(expectedValues));

该Person课程如下:

public class Person {

    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(final String name) {
        this.name = name;
    }

    // other getters and setters
}

在上面的示例中,使用Java 8技术将人员(或人员)列表转换为字符串列表,并且以旧式方式进行比较.

现在我想知道,如果有更直接或更有效的方法使用其他Java 8语句进行比较,例如allMatch()或某些Predicate<T>或其他东西.

我有一个Java 8流,我想(统一)随机选择一个元素.流可以包含从零到数万个元素的任何位置.

我已经实现了一个使用MapReduce类模式选择一个算法的算法,但是对于非常小的流,将项目收集到List中并返回一个随机索引可能更有效.但是,我必须计算它们.Streams确实有一个count()方法但是它们全部计算,我对实际计数并不感兴趣,我关心的是它是否包含多个待定数字.有谁知道这种方法是否存在？我找不到它,但可能有一些我忽略的东西或者一些聪明的伎俩,无论如何都要找到它.

PS:我知道有时候没有必要优化代码; 但我想尝试一下,只是为了体验.我是学生.

PPS:我在这里复制了我的算法,万一有人感兴趣(或者想找bug,我还没有测试过;-)

stream
    .parallel()
    .map(t -> new Pair<T, Integer>(t, 1))
    .reduce((Pair<T, Integer> t, Pair<T, Integer> u) -> {
        if (rand.nextDouble() <= (t.getValue1() / (double) (t.getValue1() + u.getValue1()))) {
            return new Pair<>(t.getValue0(), t.getValue1() + u.getValue1());
        } else {
            return new Pair<>(u.getValue0(), t.getValue1() + u.getValue1());
        }
    })
    .map(t -> t.getValue0());

(这些对来自org.javatuples,现在Java支持类似函数编程的接口,缺少元组确实会变得有点痛苦).

mylist.stream()
      .filter(m -> m.isokay() != null)
      .forEach(m -> m.dosomething()));

对于此代码,它是否在多个线程上运行？如果没有,我该怎么办？我希望每个人m.dosomething()都能在单独的线程上运行以加速这项工作.

因此,假设我在流上使用了一些随机过滤器,最直接的方法是直接输入谓词:

x.stream().filter(e -> e % 2 == 0)

我也可以简单地做一个参考并提前定义谓词:

Predicate<Integer> isEven = e -> e % 2 == 0;
...
x.stream().filter(isEven)

但我也可以使用一个函数:

private static boolean isEven(Integer integer) {
    return integer % 2 == 0;
}
...
x.stream().filter(MyClass::isEven)

据我所知,谓词当然更有限,而功能可能有副作用等.但由于像Venkat Subramaniam这样的人使用后者的解决方案,我真的很想知道:这里的主要区别是什么？

我有一个Map<String, List<Object>>.

如何将其转换为Stream,Entry<String, Object>以便构建连接查询String？

q1    a, b
q2    c, d

成

q1=a&q1=b&q2=c&q2=d

我现在正在这样做.

if (params != null && !params.isEmpty()) {
    final boolean[] flag = new boolean[1];
    params.forEach((n, vs) -> {
        vs.forEach(v -> {
            builder.append(flag[0] ? '&' : '?')
                    .append(n)
                    .append('=')
                    .append(v);
            if (!flag[0]) {
                flag[0] = true;
            }
        });
    });
}

谁能告诉我中间和终端操作有Stream什么区别？

Stream操作被组合到管道中以处理流.所有操作都是中间或终端..意思？

我能用Python完成它,我的Python代码是:

signs = {"+" : lambda a, b : a + b, "-" : lambda a, b : a - b}

a = 5
b = 3
for i in signs.keys():
    print(signs[i](a,b))

输出是:

8
2

如何通过HashMap在Java中执行相同的操作？

我有一个类值:

public class Values {
    private int count;
    private int values;
}

以及多个类型的地图列表 Map<String, Values>

Map<String, Values> map1 = new HashMap<>();
        map1 .put("aaa", new Values(1, 10));
        map1 .put("bbb", new Values(5, 50));
        map1 .put("ccc", new Values(2, 30));

Map<String, Values> map2= new HashMap<>();
        map2.put("aaa", new Values(2, 20));
        map2.put("bbb", new Values(3, 50));
        map2.put("ccc", new Values(3, 10));

List<Map<String, Values>> list = Arrays.asList(map1, map2);

地图中可以有任意数量的地图和任意数量的条目,但地图的键始终相同,只有值可以不同.为清晰起见,我的示例仅包含2个地图,每个地图仅包含3个条目.

我想获得一个具有相同键的单个映射,并使用Values对象作为对象中每个"count"和每个"value"的总和,如下所示:

{
        aaa= {
            count = 3,
            value = 30
        },
        bbb= {
            count = 8,
            value = 100
        }, …