Làm thế nào để tôi giải quyết các cảnh báo diễn viên không được kiểm tra?

Eclipse đang cho tôi một cảnh báo về hình thức sau:

Loại an toàn: Bỏ chọn truyền từ Object sang HashMap

Đây là từ một cuộc gọi đến API mà tôi không có quyền kiểm soát nào trả về Object:

HashMap<String, String> getItems(javax.servlet.http.HttpSession session) {
  HashMap<String, String> theHash = (HashMap<String, String>)session.getAttribute("attributeKey");
  return theHash;
}

Tôi muốn tránh các cảnh báo của Eclipse, nếu có thể, vì về mặt lý thuyết, chúng chỉ ra ít nhất một vấn đề về mã tiềm năng. Tôi chưa tìm thấy một cách tốt để loại bỏ cái này. Tôi có thể tự trích xuất một dòng liên quan đến một phương thức và thêm @SuppressWarnings("unchecked")vào phương thức đó, do đó hạn chế tác động của việc có một khối mã mà tôi bỏ qua các cảnh báo. Còn lựa chọn nào tốt hơn không? Tôi không muốn tắt những cảnh báo này trong Eclipse.

Trước khi tôi đến mã, nó đơn giản hơn, nhưng vẫn gây ra cảnh báo:

HashMap getItems(javax.servlet.http.HttpSession session) {
  HashMap theHash = (HashMap)session.getAttribute("attributeKey");
  return theHash;
}

Vấn đề là ở nơi khác khi bạn cố gắng sử dụng các hash bạn sẽ nhận được cảnh báo:

HashMap items = getItems(session);
items.put("this", "that");

Type safety: The method put(Object, Object) belongs to the raw type HashMap.  References to generic type HashMap<K,V> should be parameterized.

Câu trả lời rõ ràng, tất nhiên, không phải là làm các diễn viên không được kiểm soát.

Nếu nó thực sự cần thiết, thì ít nhất hãy cố gắng giới hạn phạm vi của @SuppressWarningschú thích. Theo Javadocs của nó , nó có thể đi vào các biến cục bộ; bằng cách này, nó thậm chí không ảnh hưởng đến toàn bộ phương pháp.

Thí dụ:

@SuppressWarnings("unchecked")
Map<String, String> myMap = (Map<String, String>) deserializeMap();

Không có cách nào để xác định liệu Mapthực sự nên có các tham số chung <String, String>. Bạn phải biết trước các thông số sẽ là gì (hoặc bạn sẽ tìm ra khi bạn nhận được a ClassCastException). Đây là lý do tại sao mã tạo cảnh báo, bởi vì trình biên dịch không thể biết liệu có an toàn hay không.

Thật không may, không có lựa chọn tuyệt vời ở đây. Hãy nhớ rằng, mục tiêu của tất cả những điều này là để bảo vệ loại an toàn. " Java Generics " cung cấp một giải pháp để xử lý các thư viện kế thừa không chung chung và có một thứ đặc biệt gọi là "kỹ thuật vòng lặp rỗng" trong phần 8.2. Về cơ bản, làm cho các diễn viên không an toàn, và ngăn chặn cảnh báo. Sau đó lặp qua bản đồ như thế này:

@SuppressWarnings("unchecked")
Map<String, Number> map = getMap();
for (String s : map.keySet());
for (Number n : map.values());

Nếu gặp phải loại không mong muốn, bạn sẽ nhận được thời gian chạy ClassCastException, nhưng ít nhất nó sẽ xảy ra gần với nguồn gốc của vấn đề.

Ồ; Tôi nghĩ rằng tôi đã tìm ra câu trả lời cho câu hỏi của riêng tôi. Tôi chỉ không chắc là nó có giá trị! :)

Vấn đề là dàn diễn viên không được kiểm tra. Vì vậy, bạn phải tự kiểm tra nó. Bạn không thể chỉ kiểm tra một loại tham số hóa với instanceof, bởi vì thông tin loại được tham số hóa không có sẵn trong thời gian chạy, đã bị xóa trong thời gian biên dịch.

Tuy nhiên, bạn có thể thực hiện kiểm tra từng mục trong hàm băm, với thể hiện, và khi làm như vậy, bạn có thể tạo một hàm băm mới an toàn kiểu. Và bạn sẽ không kích động bất kỳ cảnh báo.

Nhờ mmyer và Esko Luontola, tôi đã tham số hóa mã ban đầu tôi đã viết ở đây, vì vậy nó có thể được gói trong một lớp tiện ích ở đâu đó và được sử dụng cho bất kỳ HashMap tham số nào. Nếu bạn muốn hiểu rõ hơn về nó và không quen thuộc với thuốc generic, tôi khuyến khích xem lịch sử chỉnh sửa của câu trả lời này.

public static <K, V> HashMap<K, V> castHash(HashMap input,
                                            Class<K> keyClass,
                                            Class<V> valueClass) {
  HashMap<K, V> output = new HashMap<K, V>();
  if (input == null)
      return output;
  for (Object key: input.keySet().toArray()) {
    if ((key == null) || (keyClass.isAssignableFrom(key.getClass()))) {
        Object value = input.get(key);
        if ((value == null) || (valueClass.isAssignableFrom(value.getClass()))) {
            K k = keyClass.cast(key);
            V v = valueClass.cast(value);
            output.put(k, v);
        } else {
            throw new AssertionError(
                "Cannot cast to HashMap<"+ keyClass.getSimpleName()
                +", "+ valueClass.getSimpleName() +">"
                +", value "+ value +" is not a "+ valueClass.getSimpleName()
            );
        }
    } else {
        throw new AssertionError(
            "Cannot cast to HashMap<"+ keyClass.getSimpleName()
            +", "+ valueClass.getSimpleName() +">"
            +", key "+ key +" is not a " + keyClass.getSimpleName()
        );
    }
  }
  return output;
}

Đó là rất nhiều công việc, có thể là rất ít phần thưởng ... Tôi không chắc liệu tôi có sử dụng nó hay không. Tôi đánh giá cao bất kỳ ý kiến ​​nào về việc mọi người nghĩ rằng nó có giá trị hay không. Ngoài ra, tôi đánh giá cao các đề xuất cải tiến: tôi có thể làm gì tốt hơn ngoài việc ném Ass AssErrors không? Có cái gì tốt hơn tôi có thể ném? Tôi có nên làm cho nó một ngoại lệ được kiểm tra?

Trong Tùy chọn Eclipse, đi tới Java-> Trình biên dịch-> Lỗi / Cảnh báo-> Các loại chung và chọn Ignore unavoidable generic type problemshộp kiểm.

Điều này thỏa mãn mục đích của câu hỏi, tức là

Tôi muốn tránh các cảnh báo của Eclipse ...

nếu không phải là tinh thần.

Bạn có thể tạo một lớp tiện ích như sau và sử dụng nó để loại bỏ cảnh báo không được kiểm tra.

public class Objects {

    /**
     * Helps to avoid using {@code @SuppressWarnings({"unchecked"})} when casting to a generic type.
     */
    @SuppressWarnings({"unchecked"})
    public static <T> T uncheckedCast(Object obj) {
        return (T) obj;
    }
}

Bạn có thể sử dụng nó như sau:

import static Objects.uncheckedCast;
...

HashMap<String, String> getItems(javax.servlet.http.HttpSession session) {
      return uncheckedCast(session.getAttribute("attributeKey"));
}

Một số thảo luận thêm về điều này có tại đây: http://cleveralias.bloss.com/ Dùt_spearmints / 2006/01 / suppresswarning.html

Những thứ này thật khó, nhưng đây là những suy nghĩ hiện tại của tôi:

Nếu API của bạn trả về Object, thì bạn không thể làm gì - dù thế nào, bạn sẽ bị mù một cách mù quáng đối tượng. Bạn để Java ném ClassCastExceptions hoặc bạn có thể tự kiểm tra từng phần tử và ném Assertions hoặc IllegalArgumentExceptions hoặc một số thứ như vậy, nhưng các kiểm tra thời gian chạy này đều tương đương. Bạn phải loại bỏ thời gian biên dịch không được kiểm tra, bất kể bạn làm gì trong thời gian chạy.

Tôi chỉ muốn phân loại mù và để JVM thực hiện kiểm tra thời gian chạy cho tôi vì chúng tôi "biết" API sẽ trả về cái gì và thường sẵn sàng cho rằng API hoạt động. Sử dụng thuốc generic ở khắp mọi nơi phía trên diễn viên, nếu bạn cần chúng. Bạn không thực sự mua bất cứ thứ gì ở đó vì bạn vẫn có một nhóm mù duy nhất, nhưng ít nhất bạn có thể sử dụng thuốc generic từ đó trở lên để JVM có thể giúp bạn tránh các lỗi mù trong các đoạn mã khác.

Trong trường hợp cụ thể này, có lẽ bạn có thể thấy lệnh gọi SetAttribution và thấy loại đang diễn ra, vì vậy chỉ cần bỏ qua kiểu này để cùng loại trên đường ra là không vô đạo đức. Thêm một bình luận tham chiếu SetAttribution và được thực hiện với nó.

Dưới đây là một ví dụ rút gọn để tránh cảnh báo "diễn viên không được kiểm soát" bằng cách sử dụng hai chiến lược được đề cập trong các câu trả lời khác.

1. Truyền xuống Class của loại sở thích dưới dạng tham số trong thời gian chạy ( Class<T> inputElementClazz). Sau đó, bạn có thể sử dụng:inputElementClazz.cast(anyObject);

2. Để tạo kiểu cho Bộ sưu tập, hãy sử dụng ký tự đại diện? thay vì loại T chung chung để xác nhận rằng bạn thực sự không biết loại đối tượng nào mong đợi từ mã kế thừa ( Collection<?> unknownTypeCollection). Rốt cuộc, đây là điều mà cảnh báo "diễn viên không được kiểm soát" muốn nói với chúng tôi: Chúng tôi không thể chắc chắn rằng mình có được một Collection<T>, vì vậy điều trung thực cần làm là sử dụng a Collection<?>. Nếu thực sự cần thiết, một bộ sưu tập của một loại đã biết vẫn có thể được xây dựng ( Collection<T> knownTypeCollection).

Mã kế thừa được giao tiếp trong ví dụ bên dưới có thuộc tính "đầu vào" trong StructuredViewer (StructuredViewer là một tiện ích cây hoặc bảng, "đầu vào" là mô hình dữ liệu đằng sau nó). "Đầu vào" này có thể là bất kỳ loại Bộ sưu tập Java nào.

public void dragFinished(StructuredViewer structuredViewer, Class<T> inputElementClazz) {
    IStructuredSelection selection = (IStructuredSelection) structuredViewer.getSelection();
    // legacy code returns an Object from getFirstElement,
    // the developer knows/hopes it is of type inputElementClazz, but the compiler cannot know
    T firstElement = inputElementClazz.cast(selection.getFirstElement());

    // legacy code returns an object from getInput, so we deal with it as a Collection<?>
    Collection<?> unknownTypeCollection = (Collection<?>) structuredViewer.getInput();

    // for some operations we do not even need a collection with known types
    unknownTypeCollection.remove(firstElement);

    // nothing prevents us from building a Collection of a known type, should we really need one
    Collection<T> knownTypeCollection = new ArrayList<T>();
    for (Object object : unknownTypeCollection) {
        T aT = inputElementClazz.cast(object);
        knownTypeCollection.add(aT);
        System.out.println(aT.getClass());
    }

    structuredViewer.refresh();
}

Đương nhiên, mã ở trên có thể gây ra lỗi thời gian chạy nếu chúng ta sử dụng mã kế thừa với các loại dữ liệu sai (ví dụ: nếu chúng ta đặt một mảng là "đầu vào" của StructuredViewer thay vì Bộ sưu tập Java).

Ví dụ về cách gọi phương thức:

dragFinishedStrategy.dragFinished(viewer, Product.class);

Trong thế giới Phiên HTTP, bạn thực sự không thể tránh được việc sử dụng, vì API được viết theo cách đó (chỉ nhận và trả về Object ).

Với một chút công việc, bạn có thể dễ dàng tránh được các diễn viên không được kiểm soát, 'mặc dù. Điều này có nghĩa là nó sẽ biến thành một diễn viên truyền thống trao ClassCastExceptionquyền ở đó trong trường hợp xảy ra lỗi). Một ngoại lệ không được kiểm soát có thể biến thành CCEbất kỳ lúc nào sau đó thay vì điểm của diễn viên (đó là lý do tại sao đó là một cảnh báo riêng biệt).

Thay thế HashMap bằng một lớp chuyên dụng:

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);
    }
}

Sau đó, chuyển sang lớp đó thay vì Map<String,String>và mọi thứ sẽ được kiểm tra tại chính xác nơi bạn viết mã của mình. Không có bất ngờ ClassCastExceptionssau này.

Trong Android Studio nếu bạn muốn tắt kiểm tra, bạn có thể sử dụng:

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

Trong trường hợp cụ thể này, tôi sẽ không lưu trữ Bản đồ trực tiếp vào HttpSession, mà thay vào đó là một thể hiện của lớp của riêng tôi, trong đó lần lượt chứa Bản đồ (một chi tiết triển khai của lớp). Sau đó, bạn có thể chắc chắn rằng các yếu tố trong bản đồ là đúng loại.

Nhưng nếu bạn muốn kiểm tra xem nội dung của Bản đồ có đúng loại hay không, bạn có thể sử dụng một mã như thế này:

public static void main(String[] args) {
    Map<String, Integer> map = new HashMap<String, Integer>();
    map.put("a", 1);
    map.put("b", 2);
    Object obj = map;

    Map<String, Integer> ok = safeCastMap(obj, String.class, Integer.class);
    Map<String, String> error = safeCastMap(obj, String.class, String.class);
}

@SuppressWarnings({"unchecked"})
public static <K, V> Map<K, V> safeCastMap(Object map, Class<K> keyType, Class<V> valueType) {
    checkMap(map);
    checkMapContents(keyType, valueType, (Map<?, ?>) map);
    return (Map<K, V>) map;
}

private static void checkMap(Object map) {
    checkType(Map.class, map);
}

private static <K, V> void checkMapContents(Class<K> keyType, Class<V> valueType, Map<?, ?> map) {
    for (Map.Entry<?, ?> entry : map.entrySet()) {
        checkType(keyType, entry.getKey());
        checkType(valueType, entry.getValue());
    }
}

private static <K> void checkType(Class<K> expectedType, Object obj) {
    if (!expectedType.isInstance(obj)) {
        throw new IllegalArgumentException("Expected " + expectedType + " but was " + obj.getClass() + ": " + obj);
    }
}

Hàm tiện ích Object.Unchecked trong câu trả lời ở trên của Esko Luontola là một cách tuyệt vời để tránh sự lộn xộn của chương trình.

Nếu bạn không muốn SuppressWarnings trên toàn bộ phương thức, Java buộc bạn phải đặt nó trên một cục bộ. Nếu bạn cần chọn một thành viên, nó có thể dẫn đến mã như thế này:

@SuppressWarnings("unchecked")
Vector<String> watchedSymbolsClone = (Vector<String>) watchedSymbols.clone();
this.watchedSymbols = watchedSymbolsClone;

Sử dụng tiện ích sạch hơn nhiều, và rõ ràng bạn đang làm gì:

this.watchedSymbols = Objects.uncheckedCast(watchedSymbols.clone());

LƯU Ý: Tôi cảm thấy rất quan trọng khi thêm rằng đôi khi cảnh báo thực sự có nghĩa là bạn đang làm sai điều gì đó như:

ArrayList<Integer> intList = new ArrayList<Integer>();
intList.add(1);
Object intListObject = intList; 

 // this line gives an unchecked warning - but no runtime error
ArrayList<String> stringList  = (ArrayList<String>) intListObject;
System.out.println(stringList.get(0)); // cast exception will be given here

Điều mà trình biên dịch đang nói với bạn là việc cast này sẽ KHÔNG được kiểm tra trong thời gian chạy, do đó không có lỗi thời gian chạy nào được đưa ra cho đến khi bạn cố gắng truy cập dữ liệu trong vùng chứa chung.

Cảnh báo đàn áp không phải là một giải pháp. Bạn không nên thực hiện hai cấp độ đúc trong một tuyên bố.

HashMap<String, String> getItems(javax.servlet.http.HttpSession session) {

    // first, cast the returned Object to generic HashMap<?,?>
    HashMap<?, ?> theHash = (HashMap<?, ?>)session.getAttribute("attributeKey");

    // next, cast every entry of the HashMap to the required type <String, String>
    HashMap<String, String> returingHash = new HashMap<>();
    for (Entry<?, ?> entry : theHash.entrySet()) {
        returingHash.put((String) entry.getKey(), (String) entry.getValue());
    }
    return returingHash;
}

Đoán nhanh nếu bạn đăng mã của bạn có thể nói chắc chắn nhưng bạn có thể đã làm gì đó dọc theo dòng

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

Điều này sẽ tạo ra cảnh báo khi bạn cần làm

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

nó có thể đáng xem

Generics trong ngôn ngữ lập trình Java

nếu bạn không quen thuộc với những gì cần phải làm.

Tôi có thể đã hiểu nhầm câu hỏi (một ví dụ và một vài dòng xung quanh sẽ rất hay), nhưng tại sao bạn không luôn sử dụng một giao diện thích hợp (và Java5 +)? Tôi thấy không có lý do tại sao bạn muốn đúc HashMapthay vì a Map<KeyType,ValueType>. Trong thực tế, tôi không thể tưởng tượng bất kỳ lý do nào để đặt loại biến HashMapthay vì Map.

Và tại sao nguồn là một Object? Đây có phải là một loại tham số của một bộ sưu tập di sản? Nếu vậy, sử dụng thuốc generic và chỉ định loại bạn muốn.

Nếu tôi phải sử dụng API không hỗ trợ Generics .. Tôi sẽ thử và cách ly các cuộc gọi đó trong các thói quen của trình bao bọc với càng ít dòng càng tốt. Sau đó tôi sử dụng chú thích SuppressWarnings và cũng thêm các phôi an toàn loại cùng một lúc.

Đây chỉ là một sở thích cá nhân để giữ mọi thứ gọn gàng nhất có thể.

Lấy cái này, nó nhanh hơn nhiều so với việc tạo HashMap mới, nếu nó đã là một, nhưng vẫn an toàn, vì mỗi phần tử được kiểm tra theo kiểu ...

@SuppressWarnings("unchecked")
public static <K, V> HashMap<K, V> toHashMap(Object input, Class<K> key, Class<V> value) {
       assert input instanceof Map : input;

       for (Map.Entry<?, ?> e : ((HashMap<?, ?>) input).entrySet()) {
           assert key.isAssignableFrom(e.getKey().getClass()) : "Map contains invalid keys";
           assert value.isAssignableFrom(e.getValue().getClass()) : "Map contains invalid values";
       }

       if (input instanceof HashMap)
           return (HashMap<K, V>) input;
       return new HashMap<K, V>((Map<K, V>) input);
    }

Chỉ cần đánh máy nó trước khi bạn đúc nó.

Object someObject = session.getAttribute("attributeKey");
if(someObject instanceof HashMap)
HashMap<String, String> theHash = (HashMap<String, String>)someObject;  

Và đối với bất cứ ai hỏi, việc nhận các đối tượng mà bạn không chắc chắn về loại này là khá phổ biến. Rất nhiều triển khai "SOA" kế thừa đi qua các đối tượng khác nhau mà bạn không nên luôn tin tưởng. (Sự kinh hoàng!)

EDIT đã thay đổi mã ví dụ một lần để phù hợp với các cập nhật của người đăng và theo dõi một số nhận xét tôi thấy cá thể đó không chơi tốt với thuốc generic. Tuy nhiên, việc thay đổi kiểm tra để xác nhận hợp lệ đối tượng bên ngoài dường như chơi tốt với trình biên dịch dòng lệnh. Sửa đổi ví dụ bây giờ được đăng.

Hầu như mọi vấn đề trong Khoa học Máy tính đều có thể được giải quyết bằng cách thêm một mức độ gián tiếp *, hoặc một cái gì đó.

Vì vậy, giới thiệu một đối tượng không chung chung ở cấp độ cao hơn mà a Map. Không có bối cảnh, nó sẽ không có vẻ rất thuyết phục, nhưng dù sao:

public final class Items implements java.io.Serializable {
    private static final long serialVersionUID = 1L;
    private Map<String,String> map;
    public Items(Map<String,String> map) {
        this.map = New.immutableMap(map);
    }
    public Map<String,String> getMap() {
        return map;
    }
    @Override public String toString() {
        return map.toString();
    }
}

public final class New {
    public static <K,V> Map<K,V> immutableMap(
        Map<? extends K, ? extends V> original
    ) {
        // ... optimise as you wish...
        return Collections.unmodifiableMap(
            new HashMap<String,String>(original)
        );
    }
}

static Map<String, String> getItems(HttpSession session) {
    Items items = (Items)
        session.getAttribute("attributeKey");
    return items.getMap();
}

* Ngoại trừ quá nhiều cấp độ gián tiếp.

Đây là một cách tôi xử lý việc này khi tôi ghi đè equals()thao tác.

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);
    }
}

Điều này dường như hoạt động trong Java 8 (thậm chí được biên dịch với -Xlint:unchecked)

Nếu bạn chắc chắn rằng loại được trả về bởi session.getAttribution () là HashMap thì bạn không thể đánh máy theo loại chính xác đó, mà chỉ dựa vào việc kiểm tra HashMap chung

HashMap<?,?> getItems(javax.servlet.http.HttpSession session) {  
    HashMap<?,?> theHash = (HashMap<?,?>)session.getAttribute("attributeKey");
    return theHash;
} 

Eclipse sau đó sẽ gây bất ngờ cho các cảnh báo, nhưng tất nhiên điều này có thể dẫn đến các lỗi thời gian chạy khó có thể gỡ lỗi. Tôi sử dụng phương pháp này trong các bối cảnh không chỉ hoạt động.

Hai cách, một cách tránh hoàn toàn thẻ, cách còn lại sử dụng phương pháp tiện ích nhưng nghịch ngợm.
Vấn đề là Bộ sưu tập được khái quát hóa trước ...
Tôi tin rằng quy tắc của ngón tay cái là: "đúc các đối tượng một lúc" - điều này có nghĩa là gì khi cố gắng sử dụng các lớp thô trong một thế giới chung là bởi vì bạn không biết điều gì trong Bản đồ này <?,?> (và thực sự JVM thậm chí có thể thấy rằng nó thậm chí không phải là Bản đồ!), rõ ràng khi bạn nghĩ về nó mà bạn không thể sử dụng nó. Nếu bạn đã có Map <String,?> Map2 thì Hashset <String> Keys = (Hashset <String>) map2.keySet () không đưa ra cảnh báo cho bạn, mặc dù đây là "hành động đức tin" cho trình biên dịch (vì nó có thể bật ra được một TreeSet) ... nhưng nó chỉ là một đơn hành động của đức tin.

PS phản đối rằng lặp đi lặp lại như trong cách đầu tiên của tôi "là nhàm chán" và "mất thời gian", câu trả lời là "không đau không tăng": một bộ sưu tập chung được đảm bảo có chứa Map.Entry <String, String> s, và không có gì khác Bạn phải trả tiền cho sự đảm bảo này. Khi sử dụng tổng quát một cách có hệ thống khoản thanh toán này, đẹp mắt, có hình thức tuân thủ mã hóa, không phải thời gian máy!
Một trường phái suy nghĩ có thể nói rằng bạn nên đặt các cài đặt của Eclipse để tạo ra các lỗi phôi không được kiểm tra như vậy, thay vì cảnh báo. Trong trường hợp đó bạn sẽ phải sử dụng cách đầu tiên của tôi.

package scratchpad;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Vector;

public class YellowMouse {

    // First way

    Map<String, String> getHashMapStudiouslyAvoidingSuppressTag(HttpSession session) {
      Map<?, ?> theHash = (Map<?, ?>)session.getAttribute("attributeKey");

      Map<String, String> yellowMouse = new HashMap<String, String>();
      for( Map.Entry<?, ?> entry : theHash.entrySet() ){
        yellowMouse.put( (String)entry.getKey(), (String)entry.getValue() );
      }

      return yellowMouse;
    }


    // Second way

    Map<String, String> getHashMapUsingNaughtyButNiceUtilityMethod(HttpSession session) {
      return uncheckedCast( session.getAttribute("attributeKey") );
    }


    // NB this is a utility method which should be kept in your utility library. If you do that it will
    // be the *only* time in your entire life that you will have to use this particular tag!!

    @SuppressWarnings({ "unchecked" })
    public static synchronized <T> T uncheckedCast(Object obj) {
        return (T) obj;
    }


}

Điều này làm cho các cảnh báo biến mất ...

 static Map<String, String> getItems(HttpSession session) {
        HashMap<?, ?> theHash1 = (HashMap<String,String>)session.getAttribute("attributeKey");
        HashMap<String,String> theHash = (HashMap<String,String>)theHash1;
    return theHash;
}

Giải pháp: Vô hiệu hóa cảnh báo này trong Eclipse. Đừng @SuppressWarnings nó, chỉ cần vô hiệu hóa nó hoàn toàn.

Một số "giải pháp" được trình bày ở trên là không phù hợp, khiến mã không thể đọc được vì mục đích ngăn chặn cảnh báo ngớ ngẩn.