Re: Java type-casting -- Q3
grz01 wrote:
I'll re-phrase the question
(starting from scratch with a new thread).
I gave a detailed answer on the List-of-List matter in another thread with a
code example. Don't use wildcards in return types; use generic methods or
classes.
Others contributed many detailed answers to the subject as well.
You were given links to at least five strong articles on the topic.
Have you read the articles? The responses? They provide very important
background before you can approach the Pair <T, U> question.
....
So the return-type really should be:
Pair<List<Integer>,List<String>>
But since I dont think Java has any type for Pair<A,B> (?) and I dont
It's very easy to write one.
like to create yet another custom-class only for this trivial purpose,
What, you want to save your talents for the hard problems?
If it's so trivial, why'd you go with a complex, ill-understood and
excessively tricky approach instead?
Now you launch into Usenet with the exact same issues we've already answered
for you:
I decided instead to try a return-type like either
List<List<Object>> or
This tells you that the base type is 'Object'. Each list-list element can be
of a different subtype of 'Object'. You are proving only 'Object'ness about
the base type.
List<List<?>>
This tells you that the base type is some subtype of 'Object', not necessarily
'Object' itself. All list-list elements must be of the same base type, call
it 'capture#1-of ?'.
We've explained all this in detail before.
The referenced articles we've already mentioned explain all this in detail.
....
I again get the warning:
Type safety: Unchecked cast from List<capture#1-of ?> to
List<Integer>
And I dont seem to be able to rewrite it, without getting some other
error or warning.
Use generic types instead of wildcards. Use Pair <A, B>.
Any hints, what is the best way to do what I want to achieve? I.e
return a pair of lists of known, but different types (without
creating a new class) and then split the returnvalue into the two
separate lists?
Let us know that you have finished reading the posts and material already
provided, first.
Then use an approach like:
public final class Pair <T, U>
{
private final T gauche;
private final U droit;
public Pair( T g, U d )
{
gauche = g;
droit = d;
}
public T getGauche() { return gauche; }
public U getDroit() { return droit; }
}
public class Test
{
private final List <Pair <Integer, String>> intestrins
= new ArrayList <Pair <Integer, String>> ();
public Test()
{
intestrins.add( new Pair <Integer, String> ( 1.0, "one" );
}
public List <Pair <Integer, String>> getIntestrins()
{
return intestrins;
}
}
Please do report back that you've read the responses we've already given,
including now this one, and the articles we've linked for you.
For your convenience, just in case it's too much trouble for you to go back to
yesterday's posts in the "Java type-casting -- Q1" thread, in particular the
responses to you from Peter Duniho and me wherein we first cited them, at
22:16Z and 23:32Z, I repeat in this post the article links we provided:
<http://java.sun.com/docs/books/tutorial/java/generics/subtyping.html>
<http://java.sun.com/docs/books/tutorial/java/generics/wildcards.html>
<http://java.sun.com/docs/books/effective/generics.pdf>
<http://www.ibm.com/developerworks/java/library/j-jtp04298.html>
<http://www.ibm.com/developerworks/java/library/j-jtp07018.html>
--
Lew