Why do I sometimes get wildcard with Eclipse quickfix

Question

I'm clearing out the warnings in Eclipse for

 ArrayList is a raw type. References to generic type ArrayList<E> should be parameterized

but I don't understand why Eclipse uses the wildcard <?> periodically. Most of the time it puts in the correct type, i.e. ArrayList<Bicycle>. But with the following code if I do the List quickfix on Line 1 it changes to List<?> while if I do the quickfix on ArrayList first it changes to ArrayList<Object> even though the at Line 2 the method calls Line 3 and returns List<String>.

public List getList() {
    List treq = new ArrayList();
    List deptList = new ArrayList();  // Line 1
    try {
        treq = trDao.getList(status, dept, type, site);
        deptList = trDao.getDepts();  // Line 2
    }   
    catch (DAOException e) {
        setError(FORM_RESULTS, e.getMessage());
    }
    request.setAttribute("form", this);
    request.setAttribute("deptList", deptList);
    return treq;
}

and

public List<String> getDepts() {      // Line 3

Here is code which quickfixes trList as expected to ArrayList<RequestStudent> trList; The main difference I see is the use of .add()

public  ArrayList getListByRequestID(String request_id) throws DAOException {
    ArrayList trList;
    Connection connection = null;

    PreparedStatement ps = null;
    ResultSet rs = null;
    String SQL_GET_LIST = SELECT_QUERY + "WHERE trs.REQUEST_ID = ? " + "ORDER BY trs.STUDENT, trs.COURSE_ID";

    try {
        connection = ds.getConnection();
        ps = connection.prepareStatement(SQL_GET_LIST);
        ps.setString(1, request_id);
        rs = ps.executeQuery();
        trList = new ArrayList();

        while (rs.next()) {
            trList.add(mapResults(rs));  //mapResults returns a RequestStudent
        }
    }


    return trList;
}

Answer 1

Eclipse can't guess what you actually want to return from the method. Such a method, for example, is perfectly valid:

public List<?> getList(int random) {
    if (random > 10) {
        return new ArrayList<String>();
    }
    else {
        return new ArrayList<Integer>();
    }
}

So, just because

deptList = trDao.getDepts();

assigns a List<String> to deptList doesn't mean that you don't want your deptList to be a List<?>, or a List<? extends Serializable>, or a List<? extends CharSequence> or any other type compatible with List<String>.

Answer 2

Your getList() method is defined to return a raw List. Looking at the method itself, it's impossible to determine what generic type it should be returning, so Eclipse will recommend <?> or <Object> where it can (generally <?> for parameters and instances and <Object> for assignments and return types, but don't hold me to that).

new ArrayList() is equivalent to new ArrayList<Object>(), while List deptList = ... is dependant on the type it's being assigned to. Since the ArrayList is raw, Eclipse can't know what type it's supposed to be, and so goes with <?>.

You need to clean up your code to be explicit about what types you're working with. Never refer to a type with generics without specifying the generic type.

Assuming you're trying to work with Strings, your getList() should be:

public List<String> getList() {                          // add <String>
    List<String> treq = new ArrayList<>();               // add <String> and <>
    List<String> deptList = new ArrayList<>();           // add <String> and <>
    try {
        treq = trDao.getList(status, dept, type, site);
        deptList = trDao.getDepts();
    }   
    catch (DAOException e) {
        setError(FORM_RESULTS, e.getMessage());
    }
    request.setAttribute("form", this);
    request.setAttribute("deptList", deptList);
    return treq;
}

The difference in getListByRequestID() is that there is exactly one type being inserted into the List, so Eclipse can guess that you're intending to create a List of that type. In getList() there is no way to be sure what types might be inserted into treq and deptList, and so it has to fall back to <Object> or <?>.

Remember that Eclipse's suggestions are just that, suggestions. They may very well be wrong. You should only ever do them if you understand what they're doing, and are simply trying to avoid typing out boilerplate you already were planning to write.