下面是重写equals()操作时的一种处理方法。

public abstract class Section<T extends Section> extends Element<Section<T>> {
    Object attr1;

    /**
    * Compare one section object to another.
    *
    * @param obj the object being compared with this section object
    * @return true if this section and the other section are of the same
    * sub-class of section and their component fields are the same, false
    * otherwise
    */       
    @Override
    public boolean equals(Object obj) {
        if (obj == null) {
            // this exists, but obj doesn't, so they can't be equal!
            return false;
        }

        // prepare to cast...
        Section<?> other;

        if (getClass() != obj.getClass()) {
            // looks like we're comparing apples to oranges
            return false;
        } else {
            // it must be safe to make that cast!
            other = (Section<?>) obj;
        }

        // and then I compare attributes between this and other
        return this.attr1.equals(other.attr1);
    }
}

这似乎在Java 8中工作(甚至用-Xlint:unchecked编译)

下面是重写equals()操作时的一种处理方法。

public abstract class Section<T extends Section> extends Element<Section<T>> {
    Object attr1;

    /**
    * Compare one section object to another.
    *
    * @param obj the object being compared with this section object
    * @return true if this section and the other section are of the same
    * sub-class of section and their component fields are the same, false
    * otherwise
    */       
    @Override
    public boolean equals(Object obj) {
        if (obj == null) {
            // this exists, but obj doesn't, so they can't be equal!
            return false;
        }

        // prepare to cast...
        Section<?> other;

        if (getClass() != obj.getClass()) {
            // looks like we're comparing apples to oranges
            return false;
        } else {
            // it must be safe to make that cast!
            other = (Section<?>) obj;
        }

        // and then I compare attributes between this and other
        return this.attr1.equals(other.attr1);
    }
}

这似乎在Java 8中工作(甚至用-Xlint:unchecked编译)

在HTTP Session世界中，您无法真正避免强制转换，因为API就是这样编写的(只接受并返回Object)。

不过，只要稍加努力，你就可以很容易地避免这种未经检查的转换。”这意味着在发生错误时，它将转换为传统的强制转换，并在那里给出ClassCastException)。未经检查的异常可能在以后的任何时候变成CCE，而不是在强制转换的时候(这就是为什么它是一个单独的警告)。

用专用类替换HashMap:

import java.util.AbstractMap;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Attributes extends AbstractMap<String, String> {
    final Map<String, String> content = new HashMap<String, String>();

    @Override
    public Set<Map.Entry<String, String>> entrySet() {
        return content.entrySet();
    }

    @Override
    public Set<String> keySet() {
        return content.keySet();
    }

    @Override
    public Collection<String> values() {
        return content.values();
    }

    @Override
    public String put(final String key, final String value) {
        return content.put(key, value);
    }
}

然后转换为那个类，而不是Map<String,String>，所有内容都将在您编写代码的确切位置进行检查。以后不会出现意外的classcastexception。

解决方案:在Eclipse中禁用此警告。不要@SuppressWarnings，完全禁用即可。

上面提出的几个“解决方案”都太离谱了，为了抑制愚蠢的警告而使代码不可读。

在Android Studio中，如果你想禁用检查，你可以使用:

//noinspection unchecked
Map<String, String> myMap = (Map<String, String>) deserializeMap();

快速猜测一下你是否发布了你的代码，可以肯定地说，但是你可能做了一些类似的事情

HashMap<String, Object> test = new HashMap();

当你需要做的时候，哪个会产生警告

HashMap<String, Object> test = new HashMap<String, Object>();

也许值得一看

Java编程语言中的泛型

如果你不熟悉需要做什么。