标签: java-stream

我有以下for循环,它遍历一个字符串列表并存储每个单词的第一个字符StringBuilder.我想知道如何将其转换为lambda表达式

StringBuilder chars = new StringBuilder();
for (String l : list) {
    chars.append(l.charAt(0));
}  

我有一个List<Valuta>可以表示(简化)JSON风格:

[{codice = EUR,description = Euro,ratio = 1},{codice = USD,description = Dollars,ratio = 1.1}]

我想用这样的方式改变它Map<String, Valuta>:

{EUR = {codice = EUR,description = Euro,ratio = 1},USD = {codice = USD,description = Dollars,ratio = 1.1}}

我写了这个单行:

getValute().stream().collect(Collectors.groupingBy(Valuta::getCodice));

但这会返回一个Map<String, List<Valuta>>而不是我需要的东西.

我认为mapping()功能对我有用,但不知道如何.

所以如果我有一个Name对象并且有一个ArrayListtype Name(names),并且我想确定我的名字列表是否包含给定的Name对象(n),我可以用两种方式做到:

boolean exists = names.contains(n);

要么

boolean exists - names.stream().anyMatch(x -> x.equals(n));

我正在考虑这两个是否会表现相同,然后考虑如果分配n会发生什么null？

对于contains,据我所知,如果参数是null,则true在列表包含时返回null.我将如何实现这一点anyMatch- 是否可以通过使用Objects.equals(x, n)？

如果可行,那么哪种方法更有效 - 是否anyMatch可以利用懒惰和并行性？

我正在使用 aStream.Builder并且我偶然发现这个接口同时具有方法accept(T t)和add(T t). 唯一的区别是前者返回void，后者返回 a Stream.Builder。

该文档甚至提到这些方法具有相同的默认实现：

默认实现的行为就像：

accept(t)
return this;

Run Code Online (Sandbox Code Playgroud)

^{请注意，他们忘记了分号，但那是另一回事了。}

我的问题是：为什么他们有两种方法可以向流构建器添加内容？我认为这会使 API 变得混乱，我认为他们想避免这种情况。

有什么令人信服的理由这样做吗？

我试图IntStream从一个n维int数组中获得一个.有一个很好的API方法吗？我知道两个流的连接方法.

我试图解析标准输入并提取与特定模式匹配的每个字符串,计算每个匹配的出现次数,并按字母顺序打印结果.这个问题似乎与Streams API很匹配,但是我找不到从Matcher创建匹配流的简洁方法.

我通过在匹配项上实现迭代器并将其包装到Stream中解决了这个问题,但结果不是很易读.如何在不引入其他类的情况下创建正则表达式匹配流？

public class PatternCounter
{
    static private class MatcherIterator implements Iterator<String> {
        private final Matcher matcher;
        public MatcherIterator(Matcher matcher) {
            this.matcher = matcher;
        }
        public boolean hasNext() {
            return matcher.find();
        }
        public String next() {
            return matcher.group(0);
        }
    }

    static public void main(String[] args) throws Throwable {
        Pattern pattern = Pattern.compile("[a-zA-Z0-9.!#$%&’*+/=?^_`{|}~-]+@[a-zA-Z0-9-]+(?:\\.[a-zA-Z0-9-]+)");

        new TreeMap<String, Long>(new BufferedReader(new InputStreamReader(System.in))
            .lines().map(line -> {
                Matcher matcher = pattern.matcher(line);
                return StreamSupport.stream(
                        Spliterators.spliteratorUnknownSize(new MatcherIterator(matcher), Spliterator.ORDERED), false);
            }).reduce(Stream.empty(), Stream::concat).collect(groupingBy(o -> o, counting()))
        ).forEach((k, v) -> { …

感觉就像java 8流和映射函数那么冗长,它们并不是真正的改进.例如,我编写了一些使用集合生成另一个修改过的集合的代码:

private List<DartField> getDartFields(Class<?> model) {
    List<DartField> fields = new ArrayList<>();
    for (Field field : model.getDeclaredFields()) {
        if (!Modifier.isStatic(field.getModifiers())) {
            fields.add(DartField.getDartField(field));
        }
    }
    return fields;
}

这似乎是java 8流及其功能的理想用例,所以我重写了它:

private List<DartField> getDartFields(Class<?> model) {
    return Arrays.asList(model.getDeclaredFields())
            .stream()
            .filter(field -> !Modifier.isStatic(field.getModifiers()))
            .map(field -> DartField.getDartField(field))
            .collect(Collectors.toList());
}

但我不确定我更喜欢那个.这是236个字符,而普通风格的java则是239个字符.它似乎没有或多或少可读.这是很好,你没有申报ArrayList,但需要打电话.collect(Collectors.toList())和Arrays.asList(取决于数据类型)是没有任何好转.

使用.stream()这样的东西是否有一些实际的改进,我只是没有得到,或者这只是一个有趣的方式抛出任何同事不知道函数式编程的循环？

我想如果我动态地传递过滤器或映射lambdas它会很有用,但如果你不需要这样做......

在Java 8流API中,调用chars()任何String对象都会返回IntStream包含所有字符的对象.

将返回的IntStream对象转换回String？的正确方法是什么？调用toArray()会给我一个int[],任何String构造函数都不接受.

我需要在代码块中使用流中的'n'项然后完成,实质上:

 public static <T> void eat(Stream<T> stream, int n) 
     // consume n items of the stream (and throw them away)
 }

在我的情况下,我无法改变签名返回Stream<T>简单return stream.skip(n); 我必须实际丢弃流中的一些元素(不是简单的逻辑) - 为下游消费者做好准备,这不需要知道这是怎么发生的,甚至不知道发生了什么.

最简单的方法是使用limit(n),但我必须调用流终止方法来激活流,所以本质上我有:

public static <T> void skip(Stream<T> stream, int n) {
    stream.limit(n).forEach(t -> {});
}

注意:此代码完全简化了实际代码,仅用于说明目的.实际上,限制将不起作用,因为存在围绕什么/如何消耗元素的逻辑.可以把它想象成从流中消费"header"元素,然后让消费者使用"body"元素.

这个问题是关于"无所事事"的lambda t -> {}.

在JDK中的某个地方是否有"无所事事"的消费者,比如"无所事事"功能Function.identity()？

随着Collection一切都清楚了,但是怎么样以下几点:

有object一种count()方法和getPart(int i)方法.因此,提取所有对象会产生以下样板代码:

List<Part> result = new ArrayList<Part>();
for (int i = 0, i < object.count(), i++) {
    result.add(object.getPart(i));        
}
return result.stream(); 

是否有任何标准的方法来传递2个生产者:() -> object.count()并(int i) -> object.getPart(i)创建一个流？像这样:

SomeUtil.stream(object::count, object::getPart);