Java Lambda groupby通过转换减少

有人能告诉我为什么这些对lambdas没有产生类似的结果吗

public class Test {
    public static void main(String args[]){
        List<String> strings = List.of("a", "bb", "cc", "ddd");

        Map<Integer, List<Character>> result1 = strings.stream()
                .map(toStringList())
                .collect(Collectors.groupingBy(List::size
                        , Collectors.reducing(List.of(),concat())
                ));
        System.out.println(result1);

        Map<Integer,ObjStr2> result2 = strings.stream()
                .map(ObjStr1::new)
                .collect(Collectors.groupingBy(ObjStr1::getLen
                        , Collectors.reducing(new ObjStr2(), ObjStr1::to2, ObjStr2::doReduce)));

        System.out.println(result2);
    }

    private static Function<String, List<Character>> toStringList(){
        return s-> s.chars()
                .mapToObj(c->(char) c)
                .collect(Collectors.toList());
    }

    private static BinaryOperator<List<Character>> concat(){
        return (l1, l2) -> {
            return Stream.concat(l1.stream(), l2.stream()).collect(Collectors.toList());
        };
    }


}

class ObjStr1{
    String str = "";

    ObjStr1(String str) {
        this.str = str;
    }

    static ObjStr2 to2(ObjStr1 o){
        return new ObjStr2(o.str);
    }

    Integer getLen(){return str.length(); };
}

class ObjStr2{
    String str = "";

    ObjStr2(){}

    ObjStr2(String str) {
        this.str = str;
    }

    static ObjStr2 doReduce(ObjStr2 a, ObjStr2 b){
        a.str += b.str;
        return a;
    }

    @Override
    public String toString(){
        return str;
    }
}

公共类测试{
公共静态void main（字符串参数[]）{
列表字符串=列表中的（“a”、“bb”、“cc”、“ddd”）；
Map result1=strings.stream（）
.map（toStringList（））
.collect（收集器）.groupingBy（列表：：大小
，收集器。减少（列表（），concat（））
));
系统输出打印项次（结果1）；
Map result2=strings.stream（）
.map（ObjStr1:：新建）
.collect（收集器）.groupingBy（ObjStr1:：getLen
减少（新的ObjStr2（），ObjStr1:：to2，ObjStr2:：doReduce））；
系统输出打印项次（结果2）；
}
私有静态函数toStringList（）{
返回s->s.chars（）
.mapToObj（c->（char）c）
.collect（Collectors.toList（））；
}
私有静态二进制运算符concat（）{
返回（l1，l2）->{
return Stream.concat（l1.Stream（），l2.Stream（））.collect（Collectors.toList（））；
};
}
}
类ObjStr1{
字符串str=“”；
ObjStr1（字符串str）{
this.str=str；
}
静态ObjStr2至2（ObjStr1至o）{
返回新的ObjStr2（o.str）；
}
整数getLen（）{return str.length（）；}；
}
类ObjStr2{
字符串str=“”；
ObjStr2（）{}
ObjStr2（字符串str）{
this.str=str；
}
静态ObjStr2数据导出（ObjStr2 a，ObjStr2 b）{
a、 str+=b.str；
返回a；
}
@凌驾
公共字符串toString（）{
返回str；
}
}

结果：
{1=[a]，2=[b，b，c，c]，3=[d，d，d]}
{1=abbcddd，2=abbcddd，3=abbcddd}

预期：
{1=a，2=bbcc，3=ddd}

看起来你的帖子大部分都是代码；请添加更多详细信息。 看起来你的帖子大部分都是代码；请添加更多详细信息。

---

看起来你的帖子大部分都是代码；请添加更多详细信息。

我认为问题在于第二个收集器中的

新ObjStr2（）

。所有组都使用相同的起始元素

将所有内容连接到同一个对象，因为这是可变的，所以所有内容都附加到同一个对象

相反，让您的

doReduce

返回一个新对象：

static ObjStr2 doReduce(ObjStr2 a, ObjStr2 b) {
  return new ObjStr2(a.str + b.str);
}

输出：

{1=[a], 2=[b, b, c, c], 3=[d, d, d]}
{1=abbccddd, 2=abbccddd, 3=abbccddd}

---

（但如果你要这样做，不妨直接使用

字符串）。
“有人能告诉我为什么这些对lambdas来说不会产生类似的结果吗？”请给出你的预期，堆栈溢出表示您的问题没有足够的描述，这是一个好迹象，表明您应该为问题添加一些有用的描述。例如，为什么您认为它们应该产生类似的结果？我认为问题在于第二个收集器中的
新ObjStr2（）
。您对所有组使用相同的起始元素。但它应该是空的起始元素哇，这太过分了。尝试以下操作：
Map result=strings.stream（）.collect（Collectors.groupingBy（String:：length，Collectors.joining（））
——结果是
{1=a，2=bbcc，3=ddd}
，与“预期”完全匹配。