Java 8 Streams Java 8-重构流代码

我需要重构我的以下流代码：

    List<Map<String, Integer>> list5 = new ArrayList<>();
    map3 = new HashMap<>();
    map3.put("foo", 1);
    map3.put("bar", 2);
    map3.put("zzz", 6);
    list5.add(map3);
    map3 = new HashMap<>();
    map3.put("foo", 3);
    map3.put("bar", 4);
    map3.put("zzz", null);
    list5.add(map3);

    //new list with processed maps
    List<Map<String, Integer>> list6 = list5.stream()
            .map(hashmap -> {
                Map<String, Integer> newMap = hashmap.entrySet().stream()
                        .collect(HashMap::new, (m, v) -> {
                            if (v.getKey().equals("bar")) {
                                m.put(v.getKey(), v.getValue() * 2);
                            } else {
                                m.put(v.getKey(), v.getValue());
                            }
                        }, HashMap::putAll);
                return newMap;
            })
            .collect(toList());
    System.out.println(list6);

它使用IntelliJ向main（）本身添加了一个双消费者，这在这里是不需要的，并删除了代码。我需要一种单独提取的方法，如下所示：

List<Map<String, Integer>> list6 = list5.stream()
            .map(hashmap -> {
                Map<String, Integer> newMap = hashmap.entrySet().stream()
                        .collect(HashMap::new, (m, v) -> {
                            biconsumerLogic1.accept(m, v);
                        }, HashMap::putAll);
                return newMap;
            })
            .collect(toList());

我如何做到这一点？任何指点都很感激

谢谢..

怎么样：

list5.stream().forEach(map -> map.replaceAll((k,v) -> k.equals("bar") ? v * 2 : v));

这会对值进行就地替换

如果您确实需要一张新地图：

如果您希望重构，有两种选择：

备选案文1： 创建一个

双功能

，例如：

public static BiFunction<String, Integer, Integer> valueCalculator() {
    return (k,v) -> k.equals("bar") ? v * 2 : v;
}

备选案文2： 创建一个方法：

public Integer valueCalculator(String key, Integer value) {
    return key.equals("bar") ? value * 2 : value;
}

要使用，请使用方法参考：

如果是

静态
方法：

list5.stream().forEach(map -> map.replaceAll(MyClass::valueCalculator));

我更喜欢选项2，因为它更容易理解、测试和调试。
如何：

list5.stream().forEach(map -> map.replaceAll((k,v) -> k.equals("bar") ? v * 2 : v));

这会对值进行就地替换

如果您确实需要一张新地图：

如果您希望重构，有两种选择：

备选案文1：
创建一个
双功能
，例如：

public static BiFunction<String, Integer, Integer> valueCalculator() {
    return (k,v) -> k.equals("bar") ? v * 2 : v;
}

备选案文2：
创建一个方法：

public Integer valueCalculator(String key, Integer value) {
    return key.equals("bar") ? value * 2 : value;
}

要使用，请使用方法参考：

如果是
静态
方法：

list5.stream().forEach(map -> map.replaceAll(MyClass::valueCalculator));

我更喜欢选项2，因为它更容易理解、测试和调试。
请看，问题在于使用流。你已经设计过度了，你不需要大部分

看：

List newList=newarraylist（列表）；
newList.replaceAll（每个映射->{
Map Map=新的HashMap（eachMap）；
地图。计算机呈现（“条形图”，（k，v）->v*2）；
返回图；
});

要替换操作，您需要执行以下操作：

BiFunction<String, Integer, Integer> action = (k,v) -> v * 2;

newList.replaceAll(eachMap -> {
  Map<String, Integer> map = new HashMap<>(eachMap);
  map.computeIfPresent("bar", action);
  return map;
});

static <K, V> List<Map<K, V>> process(
        List<Map<K, V>> source,
        BiConsumer<? super Map<K, V>, ? super Map.Entry<K, V>> accumulator) {

    return source.stream()
        .map(m -> m.entrySet().stream()
            .collect(HashMap::new, accumulator, Map::putAll))
        .collect(Collectors.toList());
}

双功能动作=（k，v）->v*2；
newList.replaceAll（每个映射->{
Map Map=新的HashMap（eachMap）；
map.computefpresent（“bar”，动作）；
返回图；
});

现在，您可以将整个过程提取到一个单独的方法中，并接受
列表
和
操作
（也可能是
“bar”
变量）以及参数，这里有一个值替换器。
请看，问题在于使用流。你已经设计过度了，你不需要大部分

看：

List newList=newarraylist（列表）；
newList.replaceAll（每个映射->{
Map Map=新的HashMap（eachMap）；
地图。计算机呈现（“条形图”，（k，v）->v*2）；
返回图；
});

要替换操作，您需要执行以下操作：

BiFunction<String, Integer, Integer> action = (k,v) -> v * 2;

newList.replaceAll(eachMap -> {
  Map<String, Integer> map = new HashMap<>(eachMap);
  map.computeIfPresent("bar", action);
  return map;
});

static <K, V> List<Map<K, V>> process(
        List<Map<K, V>> source,
        BiConsumer<? super Map<K, V>, ? super Map.Entry<K, V>> accumulator) {

    return source.stream()
        .map(m -> m.entrySet().stream()
            .collect(HashMap::new, accumulator, Map::putAll))
        .collect(Collectors.toList());
}

双功能动作=（k，v）->v*2；
newList.replaceAll（每个映射->{
Map Map=新的HashMap（eachMap）；
map.computefpresent（“bar”，动作）；
返回图；
});

现在，您可以将整个过程提取到一个单独的方法中，并接受
列表
和
操作
（可能还有
“bar”
变量）以及参数，这里是您的值替换程序。
我认为有更好的方法来完成您实际正在做的事情。但是严格回答如何提取和重构指定的代码段，您可以这样做：

BiFunction<String, Integer, Integer> action = (k,v) -> v * 2;

newList.replaceAll(eachMap -> {
  Map<String, Integer> map = new HashMap<>(eachMap);
  map.computeIfPresent("bar", action);
  return map;
});

static <K, V> List<Map<K, V>> process(
        List<Map<K, V>> source,
        BiConsumer<? super Map<K, V>, ? super Map.Entry<K, V>> accumulator) {

    return source.stream()
        .map(m -> m.entrySet().stream()
            .collect(HashMap::new, accumulator, Map::putAll))
        .collect(Collectors.toList());
}

静态列表过程(
列出来源，
BiConsumer我认为有更好的方法来做你实际正在做的事情。但是严格地回答如何提取和重构指定的代码，你可以这样做：

BiFunction<String, Integer, Integer> action = (k,v) -> v * 2;

newList.replaceAll(eachMap -> {
  Map<String, Integer> map = new HashMap<>(eachMap);
  map.computeIfPresent("bar", action);
  return map;
});

static <K, V> List<Map<K, V>> process(
        List<Map<K, V>> source,
        BiConsumer<? super Map<K, V>, ? super Map.Entry<K, V>> accumulator) {

    return source.stream()
        .map(m -> m.entrySet().stream()
            .collect(HashMap::new, accumulator, Map::putAll))
        .collect(Collectors.toList());
}

静态列表过程(
列出来源，
BiConsumer下面是我使用BiConsumer进行重构的版本：

psv main(...) {
    List<Map<String, Integer>> newList = processMapData(origList, accumulator());
    System.out.println(newList);
}

private static List<Map<String, Integer>> processMapData(List<Map<String, Integer>> origList, BiConsumer<HashMap<String, Integer>, Map.Entry<String, Integer>> accumulator) {
    return origList.stream()
                .map(hashmap -> {
                    Map<String, Integer> newMap = hashmap.entrySet().stream()
                            .collect(HashMap::new, accumulator, HashMap::putAll);
                    return newMap;
                })
                .collect(toList());
}

private static BiConsumer<HashMap<String, Integer>, Map.Entry<String, Integer>> accumulator() {
    return (m, v) -> {
        m.put(v.getKey(), v.getKey().equals("bar") ? v.getValue() * 2: v.getValue());
    };
}

psv主管道（…）{
List newList=processMapData（origList，acculator（））；
System.out.println（newList）；
}
私有静态列表processMapData（列表或列表、双消费者累加器）{
返回origList.stream（）
.map（hashmap->{
Map newMap=hashmap.entrySet（）.stream（）
.collect（HashMap:：new、累加器、HashMap:：putAll）；
返回newMap；
})
.collect（toList（））；
}
专用静态双消费累加器（）{
返回（m，v）->{
m、 put（v.getKey（），v.getKey（）.equals（“bar”）？v.getValue（）*2:v.getValue（））；
};
}

我可以利用更多的控件，动态地将累加器注入到
processMapData
函数中。
感谢@Federico对双消费者函数的建议。
下面是我使用双消费者进行重构的版本：

psv main(...) {
    List<Map<String, Integer>> newList = processMapData(origList, accumulator());
    System.out.println(newList);
}

private static List<Map<String, Integer>> processMapData(List<Map<String, Integer>> origList, BiConsumer<HashMap<String, Integer>, Map.Entry<String, Integer>> accumulator) {
    return origList.stream()
                .map(hashmap -> {
                    Map<String, Integer> newMap = hashmap.entrySet().stream()
                            .collect(HashMap::new, accumulator, HashMap::putAll);
                    return newMap;
                })
                .collect(toList());
}

private static BiConsumer<HashMap<String, Integer>, Map.Entry<String, Integer>> accumulator() {
    return (m, v) -> {
        m.put(v.getKey(), v.getKey().equals("bar") ? v.getValue() * 2: v.getValue());
    };
}

psv主管道（…）{
List newList=processMapData（origList，acculator（））；
System.out.println（newList）；
}
私有静态列表processMapData（列表或列表、双消费者累加器）{
返回origList.stream（）
.map（hashmap->{
Map newMap=hashmap.entrySet（）.stream（）
.collect（HashMap:：new、累加器、HashMap:：putAll）；
返回newMap；
})
.collect（toList（））；
}
专用静态双消费累加器（）{
返回（m，v）->{
m、 put（v.getKey（），v.getKey（）.equals（“bar”）？v.getValue（）*2:v.getValue（））；
};
}

我可以利用更多的控件，动态地将累加器注入到
processMapData
函数中。
感谢@Federico对双消费者函数的建议。
如果你能告诉我你在这里想做什么会更好。也许有人有比重构你的代码更好的解决方案。请看我下面的评论@BohemianYes我会这么做的。。谢谢你的提醒。。所以今天不允许我，我想我除了我自己的答案w之外不能我将在24小时内完成。如果你能告诉我你想在这里做什么会更好。也许有人有比重构你的代码更好的解决方案。请看下面的我的评论@BohemianYes我会这么做的。。谢谢提醒。。所以今天不允许我，我想我不能，除非我自己在24小时内回答。不。我的外部流代码不会o保持不变。唯一要改变的部分是if（）{}逻辑。在这里，我通过乘法来改变值，但我可能有一个逻辑来做其他事情。所以我想动态注入该逻辑。我可以有几个这样的场景。@Gauravsani我添加了一些如何重构
replaceAll
的选项