如何用lambda表示代码？

我想把列表转换成地图

public Map<Integer, A> toMap(List<A> list) {
    Map<Integer, A> map = new HashMap<>();
    int sum = 0;
    for (int i = 0; i < list.size(); i++) {
        if (list.get(i).getKey() != 0) {
            sum += Math.abs(list.get(i).getKey());
            map.put(sum, list.get(i));
        }
    }
    return map;
}

publicmap（列表）{
Map Map=newhashmap（）；
整数和=0；
对于（int i=0；i

如何用lambda来表达这一点？

类似这样的内容：

List<Integer> mList = Arrays.asList(1,2,3,4,5,2,-1,3,0,1);

Map<Integer, Integer> map = mList.stream()
        .filter(i -> i != 0)
        .collect(Collectors.toMap(new Function<Integer, Integer>() {
            int sum = 0;
            @Override
            public Integer apply(Integer integer) {
                sum += integer;
                return sum;
            }
        }, Function.identity()));

List mList=Arrays.asList（1,2,3,4,5,2，-1,3,0,1）；
Map Map=mList.stream（）
.filter（i->i！=0）
.collect（Collectors.toMap（新函数（）{
整数和=0；
@凌驾
公共整数应用（整数）{
总和+=整数；
回报金额；
}
}，Function.identity（））；

我已经为

List

做了，现在您应该为

List

做同样的事情

---

提示：将

Integer

替换为

A

可能使用

foreach

会更有效。当它违反时，不必将所有内容都转换为流，

for

，

foreach

，

，而

循环没有死。稍后我将给出更大一点的流代码

弗雷奇 使用stream.collect（收集器）的流

import java.util.List；
导入java.util.Map；
导入java.util.concurrent.AtomicInteger；
导入java.util.function.function；
导入java.util.stream.collector；
导入静态java.util.function.function.identity；
公共地图toMap（列表）{
AtomicInteger prevKey=新的AtomicInteger（0）；
return list.stream（）.filter（it->it.getKey（）！=0）
.collect（Collectors.toMap）（curry（prevKey:：addAndGet，A:：getKey）
，identity（））；
}
//例如：AtomicInteger.addAndGet（A.getKey（））
函数库（函数目标、函数映射器）{
return（it）->target.apply（mapper.apply（it））；
}

使用stream.collect流（供应商、双消费者、双消费者）

import java.util.AbstractMap.SimpleEntry；
导入java.util.Map.Entry；
导入java.util.Stack；
导入java.util.stream.collector；
导入java.util.Map；
公共地图toMap（列表）{
return list.stream（）.filter（it->it.getKey（）！=0）。
collect（Stack:：new，this:：calculateKey，Stack:：addAll）.stream（）。
collect（Collectors.toMap（条目：：getKey，条目：：getValue））；
}
专用void calculateKey（堆栈，A）{
整数prevKey=stack.isEmpty（）？0:stack.peek（）.getKey（）；
整数key=prevKey+a.getKey（）；
stack.push（新的simplentry（key，a））；
}

先做。然后告诉我们如果你有错误你做了什么。不要求我们为您编码。删除代码重复（调用

list.get（i）

三次和

.getKey（）

两次）将有助于您的原始循环

for（A:list）{int key=A.getKey（）；if（key！=0）map.put（sum+=Math.abs（key），A）；}

。。。是的；-）但是它可能仍然很长。。。虽然没有道理，但它可能是；-）源代码是一个

列表

，而不是

列表

…@Holger，这让OP有机会对

列表

执行相同的操作。这更像是一个例子，而不是对问题的直接回答。那么你根本不应该提供填鸭式代码。它只是不一致。要么你提供一个完整的解决方案，要么你告诉OP，如何自己解决。提供一个不完整的解决方案而不解释它的作用，这两者都不是。好吧，至少它足以表明它不会简化原始循环代码。也许这已经对手术有所帮助了…

public Map<Integer, A> toMap(List<A> list) {
    Map<Integer, A> map = new HashMap<>();
    int prevKey = 0;
    for (A item : list) {
        int key = item.getKey();

        if (key != 0) {
            map.put(prevKey += Math.abs(key), item);
        }
    }
    return map;
}

public Map<Integer, A> toMap(List<A> list) {
    Map<Integer, A> map = new HashMap<>();
    int prevKey = 0;
    for (A item : each(list.stream().filter(it -> it.getKey() != 0))) {
        map.put(prevKey += Math.abs(item.getKey()), item);
    }
    return map;
}

private static <T> Iterable<? extends T> each(Stream<T> stream) {
    return stream::iterator;
}

import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.Function;
import java.util.stream.Collectors;
import static java.util.function.Function.identity;

public Map<Integer, A> toMap(List<A> list) {
    AtomicInteger prevKey = new AtomicInteger(0);
    return list.stream().filter(it -> it.getKey() != 0)
               .collect(Collectors.toMap(curry(prevKey::addAndGet, A::getKey)
                                              ,identity()));
}

// e.g: AtomicInteger.addAndGet(A.getKey())
<T, U, R> Function<T, R> curry(Function<U, R> target, Function<T, U> mapper) {
    return (it) -> target.apply(mapper.apply(it));
}

import java.util.AbstractMap.SimpleEntry;
import java.util.Map.Entry;
import java.util.Stack;
import java.util.stream.Collectors;
import java.util.Map;

public Map<Integer, A> toMap(List<A> list) {
    return list.stream().filter(it -> it.getKey() != 0).
            collect(Stack::new, this::calculateKey, Stack::addAll).stream().
            collect(Collectors.toMap(Entry::getKey, Entry::getValue));
}

private void calculateKey(Stack<Entry<Integer, A>> stack, A a) {
    Integer prevKey = stack.isEmpty() ? 0 : stack.peek().getKey();

    Integer key = prevKey + a.getKey();

    stack.push(new SimpleEntry<>(key, a));
}