The return type for generics topic that I not clear.

[Tanakorn Numrubporn]

This code is derive from K&B Book:

Given the String implements java.lang.CharSequence, and:
import java.util.*;
public class LongWordFinder{
    public static void main(String[] args){
        String[] array = {"123, "12345678", "1", "12", "1234567890"};
        List<String> list = Arrays.asList(array);
        Collection<String> resultList = getLongWords(list);
    }
    // INSERT DECLARATION HERE
    {
        Collection<E> longWords = new ArrayList<E>();
        for(E word : coll){
            if(word.length() > 6)
                longWords.add(word);
        }
        return longWords
    }
}
Which declarations could be inserted at // INSERT DECLARATION HERE so that the program will compile and run?(Choose all that apply.)
A. public static <E extends CharSequence> 
       Collection<? extends CharSequence> getLongWords(Collection<E> coll)
...
F. public static <E extends CharSequence> 
       Collection<E> getLongWords(Collection<E> coll)
...

The answer is F.
My answer is A & F choices.

The authors said that 'A is close, but it's wrong because the return value is too vague. The last line of the method expects the return value to be Collection<String>, not Collection<? extends CharSequence>.'

My problem is:
Why Collectiion<? extends CharSequence> is not correct.? String is implements java.lang.CharSequencen, which follow by the question, So <? extends CharSequence> is can be <String>. The word '...too vague...' of authors is unclear.

Thank you
Tanakorn

[Barry Gaunt]

<? extends CharSequence> represents the family of classes {CharBuffer, Segment, String, StringBuffer, StringBuilder }. So you could be attempting to assign a Collection<Segment>, a Collection<String>, a Collection<StringBuffer>, or a Collection<StringBuilder> to that Collection of Strings. The compiler will not allow that because the returned type is not specified enough (that is "too vague").

A return type of Collection<String> is just right. You could return the raw type Collection, but then you get an unchecked warning.
[ January 17, 2007: Message edited by: Barry Gaunt ]

[Tanakorn Numrubporn]

Thank you very much.
Your reply is very clear.

Tanakorn

[Tanakorn Numrubporn]

Oh! I almost forget.
I have another question. from the same book in the same topic (return type of generics)

The question is:

Given a method declared as:
    public static <E extends Number> List<? super E> process(List<E> nums)
 
A programmer wants to use this method like this:
 
    //INSERT DECLARATIONS HERE
    output = process(input);
 
Which pairs of declarations could be placed at // INSERT DECLARATIONS HERE to allow the code to compile?
 
...
C. ArrayList<Integer> input = null;
   List<Number> output = null;
...

The answer is others choices (not choice C.)
The reason that authors give to me is '...C is wrong because the return type evaluates to List<Ingeter>, and that can't be assigned to a variable of type List<Number>...

Although the given reason, I still don't know why this choice is wrong.

First: List<? super E> can be List<Number> so I don't think so this is a problem for return value. Because, in this choice, E is Integer and <? super E> also can be <Number>.

Second: How can I exactly know that the return type is evaluates to List<Integer>?. List<? super E> is also 'too vague' so the return type can be anything such as <Integer>, <Long>, <Short> etc.

[Barry Gaunt]

This last example is incorrect (see K & B errata). It should be:
public static <E extends Number> List<E> process(List<E> nums)

[Tanakorn Numrubporn]

Thank you again.