Java 在反编译类中工作时出现ImmutablePair和Pair编译错误

我创建了以下最小的、可复制的示例

我有一个编译错误

import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

import org.apache.commons.lang3.tuple.ImmutablePair;
import org.apache.commons.lang3.tuple.Pair;
public class TestClass
{

    /**
     * @param args
     */
    public static void main(final String[] args)
    {
        final Map<ObjectAttributesValueContainer, Set<CompareAttribute>> differences = null;

        final Map<CompareAttribute, Collection<ObjectAttributesValueContainer>> differentObjectsForAttributes = (Map) differences
                .entrySet().stream().flatMap((entry) -> {
                    return ((Set) entry.getValue()).stream().map((attr) -> {
                        return new ImmutablePair(entry.getKey(), attr);
                    });
                }).collect(Collectors.toMap(Pair::getValue, (pair) -> {
                    return new HashSet(Collections.singleton(pair.getKey()));
                }, (a1, a2) -> {
                    a1.addAll(a2);
                    return a1;
                }));
    }

}


class CompareAttribute
{
    private String qualifier;
    private String group;

    public CompareAttribute(final String qualifier)
    {
        this.qualifier = qualifier;
    }

    public CompareAttribute(final String qualifier, final String group)
    {
        this(qualifier);
        this.group = group;
    }

    public String getQualifier()
    {
        return this.qualifier;
    }

    public void setQualifier(final String qualifier)
    {
        this.qualifier = qualifier;
    }

    public String getGroup()
    {
        return this.group;
    }

    public void setGroup(final String group)
    {
        this.group = group;
    }

    @Override
    public boolean equals(final Object o)
    {
        if (this == o)
        {
            return true;
        }
        else if (o == null)
        {
            return false;
        }
        else if (o.getClass() != this.getClass())
        {
            return false;
        }
        else
        {
            final CompareAttribute that = (CompareAttribute) o;
            if (!this.qualifier.equals(that.qualifier))
            {
                return false;
            }
            else if (((CompareAttribute) o).getGroup() == null && this.group == null)
            {
                return true;
            }
            else
            {
                return ((CompareAttribute) o).getGroup() != null && this.group != null ? this.group.equals(that.group) : false;
            }
        }
    }

    @Override
    public int hashCode()
    {
        int result = this.qualifier.hashCode();
        if (this.group != null)
        {
            result = 31 * result + this.group.hashCode();
        }

        return result;
    }

    @Override
    public String toString()
    {
        return this.qualifier + (this.group != null ? '@' + this.group : "");
    }
}

class ObjectAttributesValueContainer
{
    private final Object object;
    private final Map<CompareAttribute, Object> attributeValues;

    public ObjectAttributesValueContainer(final Object object)
    {
        this.object = object;
        this.attributeValues = new HashMap();
    }

    public Object getObject()
    {
        return this.object;
    }

    public Map<CompareAttribute, Object> getAttributeValues()
    {
        return this.attributeValues;
    }
}

日蚀。“类型对未定义适用于此处的getValue（对象）”

IntelliJ说

我试图使用jar文件中的部分逻辑，所以我并没有编写这个逻辑，但这段代码在反编译类中运行良好

我把这个逻辑放在自己的类中，并得到编译错误

import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

import org.apache.commons.lang3.tuple.ImmutablePair;
import org.apache.commons.lang3.tuple.Pair;
public class TestClass
{

    /**
     * @param args
     */
    public static void main(final String[] args)
    {
        final Map<ObjectAttributesValueContainer, Set<CompareAttribute>> differences = null;

        final Map<CompareAttribute, Collection<ObjectAttributesValueContainer>> differentObjectsForAttributes = (Map) differences
                .entrySet().stream().flatMap((entry) -> {
                    return ((Set) entry.getValue()).stream().map((attr) -> {
                        return new ImmutablePair(entry.getKey(), attr);
                    });
                }).collect(Collectors.toMap(Pair::getValue, (pair) -> {
                    return new HashSet(Collections.singleton(pair.getKey()));
                }, (a1, a2) -> {
                    a1.addAll(a2);
                    return a1;
                }));
    }

}


class CompareAttribute
{
    private String qualifier;
    private String group;

    public CompareAttribute(final String qualifier)
    {
        this.qualifier = qualifier;
    }

    public CompareAttribute(final String qualifier, final String group)
    {
        this(qualifier);
        this.group = group;
    }

    public String getQualifier()
    {
        return this.qualifier;
    }

    public void setQualifier(final String qualifier)
    {
        this.qualifier = qualifier;
    }

    public String getGroup()
    {
        return this.group;
    }

    public void setGroup(final String group)
    {
        this.group = group;
    }

    @Override
    public boolean equals(final Object o)
    {
        if (this == o)
        {
            return true;
        }
        else if (o == null)
        {
            return false;
        }
        else if (o.getClass() != this.getClass())
        {
            return false;
        }
        else
        {
            final CompareAttribute that = (CompareAttribute) o;
            if (!this.qualifier.equals(that.qualifier))
            {
                return false;
            }
            else if (((CompareAttribute) o).getGroup() == null && this.group == null)
            {
                return true;
            }
            else
            {
                return ((CompareAttribute) o).getGroup() != null && this.group != null ? this.group.equals(that.group) : false;
            }
        }
    }

    @Override
    public int hashCode()
    {
        int result = this.qualifier.hashCode();
        if (this.group != null)
        {
            result = 31 * result + this.group.hashCode();
        }

        return result;
    }

    @Override
    public String toString()
    {
        return this.qualifier + (this.group != null ? '@' + this.group : "");
    }
}

class ObjectAttributesValueContainer
{
    private final Object object;
    private final Map<CompareAttribute, Object> attributeValues;

    public ObjectAttributesValueContainer(final Object object)
    {
        this.object = object;
        this.attributeValues = new HashMap();
    }

    public Object getObject()
    {
        return this.object;
    }

    public Map<CompareAttribute, Object> getAttributeValues()
    {
        return this.attributeValues;
    }
}

import java.util.Collection；
导入java.util.Collections；
导入java.util.HashMap；
导入java.util.HashSet；
导入java.util.Map；
导入java.util.Set；
导入java.util.stream.collector；
导入org.apache.commons.lang3.tuple.ImmutablePair；
导入org.apache.commons.lang3.tuple.Pair；
公共类TestClass
{
/**
*@param args
*/
公共静态void main（最终字符串[]args）
{
最终映射差异=空；
最终映射差异对象属性=（映射）差异
.entrySet（）.stream（）.flatMap（（条目）->{
return（（Set）entry.getValue（））.stream（）.map（（attr）->{
返回新的ImmutablePair（entry.getKey（），attr）；
});
}).collect（Collectors.toMap（Pair:：getValue，（Pair）->{
返回新的HashSet（Collections.singleton（pair.getKey（））；
}，（a1，a2）->{
a1.addAll（a2）；
返回a1；
}));
}
}
类比较属性
{
私有字符串限定符；
私有字符串组；
公共比较属性（最终字符串限定符）
{
this.qualifier=限定符；
}
公共比较属性（最终字符串限定符、最终字符串组）
{
这个（限定词）；
this.group=组；
}
公共字符串getQualifier（）
{
返回此.qualifier；
}
公共void setQualifier（最终字符串限定符）
{
this.qualifier=限定符；
}
公共字符串getGroup（）
{
返回此.group；
}
公共void集合组（最终字符串组）
{
this.group=组；
}
@凌驾
公共布尔等于（最终对象o）
{
if（this==o）
{
返回true；
}
else如果（o==null）
{
返回false；
}
如果（o.getClass（）！=this.getClass（）），则为else
{
返回false；
}
其他的
{
最终的CompareAttribute，它=（CompareAttribute）o；
如果（！this.qualifier.equals（that.qualifier））
{
返回false；
}
else if（（（CompareAttribute）o）.getGroup（）==null&&this.group==null）
{
返回true；
}
其他的
{
return（（CompareAttribute）o.getGroup（）！=null&&this.group！=null？this.group.equals（that.group）：false；
}
}
}
@凌驾
公共int hashCode（）
{
int result=this.qualifier.hashCode（）；
如果（this.group！=null）
{
result=31*result+this.group.hashCode（）；
}
返回结果；
}
@凌驾
公共字符串toString（）
{
返回this.qualifier+（this.group！=null？'@'+this.group:）；
}
}
类ObjectAttributesValueContainer
{
私有最终客体；
私有最终地图属性值；
public ObjectAttributesValueContainer（最终对象）
{
this.object=对象；
this.attributeValues=新的HashMap（）；
}
公共对象getObject（）
{
返回此.object；
}
公共映射getAttributeValues（）
{
返回此.attributeValue；
}
}

您无法强制转换为特定类型的

映射，因此我删除了该映射。你的

return ((Set) entry.getValue()).stream().map((attr) -> {...

无法工作，因为
flatmap
必须返回
流

我做了一些假设，并添加了一些类型。现在至少它可以编译了。首先，我删除了警告：

public ObjectAttributesValueContainer(final Object object) {
  this.object = object;
//  this.attributeValues = new HashMap();
  this.attributeValues = new HashMap<>();
}

public ObjectAttributesValueContainer（最终对象）{
this.object=对象；
//this.attributeValues=新的HashMap（）；
this.attributeValues=新的HashMap（）；
}

然后我跟踪了这些类型：

final Map<CompareAttribute, Collection<ObjectAttributesValueContainer>> 
  differentObjectsForAttributes = 
  differences
        .entrySet()
        .stream()
        .flatMap((entry) -> 
                   entry.getValue() // Set<CompareAttribute>
                   .stream()
                   .map((attr) -> {return new ImmutablePair<ObjectAttributesValueContainer,CompareAttribute>
                                                            (entry.getKey(), attr);}
                 ))
        // now we have a stream of ImmutablePair<ObjectAttributesValueContainer,CompareAttribute>
         .collect(Collectors.toMap(Pair::getValue, 
                                   (pair) -> {return new HashSet<ObjectAttributesValueContainer>
                                                               (Collections.singleton(pair.getKey()));
                                             }, 
                                   (a1, a2) -> {a1.addAll(a2);
                                                return a1;
                                               }
                                   ));

最终地图
不同的对象属性=
分歧
.entrySet（）
.stream（）
.flatMap（（条目）->
entry.getValue（）//设置
.stream（）
.map（（attr）->{返回新的ImmutablePair
（entry.getKey（），attr）；}
))
//现在我们有了一个ImmutablePair流
.collect（收集器）.toMap（对：：getValue、，
（对）->{返回新哈希集
（Collections.singleton（pair.getKey（））；
}, 
（a1，a2）->{a1.addAll（a2）；
返回a1；
}
));
您无法强制转换为特定类型的
映射，因此我删除了该映射。你的

return ((Set) entry.getValue()).stream().map((attr) -> {...

无法工作，因为
flatmap
必须返回
流

我做了一些假设，并添加了一些类型。现在至少它可以编译了。首先，我删除了警告：

public ObjectAttributesValueContainer(final Object object) {
  this.object = object;
//  this.attributeValues = new HashMap();
  this.attributeValues = new HashMap<>();
}

public ObjectAttributesValueContainer（最终对象）{
this.object=对象；
//this.attributeValues=新的HashMap（）；
this.attributeValues=新的HashMap（）；
}

然后我跟踪了这些类型：

final Map<CompareAttribute, Collection<ObjectAttributesValueContainer>> 
  differentObjectsForAttributes = 
  differences
        .entrySet()
        .stream()
        .flatMap((entry) -> 
                   entry.getValue() // Set<CompareAttribute>
                   .stream()
                   .map((attr) -> {return new ImmutablePair<ObjectAttributesValueContainer,CompareAttribute>
                                                            (entry.getKey(), attr);}
                 ))
        // now we have a stream of ImmutablePair<ObjectAttributesValueContainer,CompareAttribute>
         .collect(Collectors.toMap(Pair::getValue, 
                                   (pair) -> {return new HashSet<ObjectAttributesValueContainer>
                                                               (Collections.singleton(pair.getKey()));
                                             }, 
                                   (a1, a2) -> {a1.addAll(a2);
                                                return a1;
                                               }
                                   ));

最终地图
不同的对象属性=
分歧
.entrySet（）
.stream（）
.flatMap（（条目）->
entry.getValue（）//设置
.stream（）
.map（（attr）->{返回新的ImmutablePa