Re: Newbie Question: ArrayLists and Referencing
Patricia Shanahan <pats@acm.org> wrote:
Taria wrote:
G'morning!
I apologize for paraphasing my concern and bad naming conventions. I
should have labelled my code as psuedo. In any case, I created the
SSCCE (thank you for the correction) with the compiler error.
import java.util.*;
public class MyProg3 {
public static void main(String[] args) {
List table = new ArrayList ();
ArrayList <Integer> data = new ArrayList <Integer>();
data.add(1);
data.add(3);
data.add(4);
data.add(2);
table.add(data);
ArrayList <Integer> node = new ArrayList <Integer> ();
node.add(table.get(0).get(0));
Taria, at this point, what does the complier think:
table.get(0)
will return?
It will return the ArrayList you called data. But the compiler will not
look at your code and figure that out. You must tell the compiler what it
will return when you define table.
When you defined table, you just defined it as ArrayList. You didn't
specify what type of objects you were going to put into it. As such, the
compiler has not idea what might be in the ArrayList, or what type of
object is going to come out. So it simply assumes the type is Object (the
default if you don't tell it what you are going to put in it).
You then tried to do a .get(0) on what came out of the table. The compiler
will not let you do that because get() is not a method that is known to
work on a object of type Object.
You can make you code work one of two ways.
You can use Generics, and tell the compiler what type of objects will be in
the ArrayList. That is the correct modern way to do it. But it's
confusing if you don't understand generics yet.
Patricia shows you how to do that here:
import java.util.*;
public class MyProg3 {
public static void main(String[] args) {
List<List<Integer>> table = new ArrayList<List<Integer>>();
List<Integer> data = new ArrayList<Integer>();
data.add(1);
data.add(3);
data.add(4);
data.add(2);
table.add(data);
ArrayList<Integer> node = new ArrayList<Integer>();
node.add(table.get(0).get(0));
System.out.println(node);
}
}
Once you define all the ArrayLists correctly, the node.add() works fine as
you wrote it.
That's because the compiler knows that get() is a method that you can use
on a List, so "table.get(0)" compiles fine. And the compiler also knows
that table is a List which holds other Lists which holds Integer objects.
So it knows that table.get(0) will return a list. So it knows that
table.get(0).get(0) is always valid, and that it will return an Integer
object.
And, when you try do do node.add() with an Integer, that also fits how node
was defined, (a list of Integer objects).
Everything works fine and the compiler won't let you make the mistake.
But the other option, (the old and bad way) is to not use Generics (only
because you don't really understand them yet), and simply tell the compiler
what to expect by casting everything as you use it.
Here's how to write your code without using generics:
import java.util.*;
public class MyProg3
{
public static void main(String[] args) {
ArrayList table = new ArrayList();
ArrayList data = new ArrayList();
data.add(1);
data.add(3);
data.add(4);
data.add(2);
table.add(data);
ArrayList node = new ArrayList();
//trying to assign the value at table (0,0) to node(0)
node.add(((ArrayList)table.get(0)).get(0));
}
}
All you have to do, is tell the computer that the table.get(0) is going to
be returning an ArrayList object. And you do that, by adding the cast and
the parens as I did above.
This is dangerous, because if you make a mistake in your code, and it turns
out that something else in your table at position 0, then your program will
blow up at run time with cast exception. Using Generics, (which is more
complex) allows the compiler to check at compile time that you never put
anything except ArrayLists, into your table.
Without generics, you can put anything you want into ArrayLists, but you
have to tell the compiler with a cast, what it is when you take it out,
before you can use it.
--
Curt Welch http://CurtWelch.Com/
curt@kcwc.com http://NewsReader.Com/