In my sketch, I'm constructing an ArrayList containing ArrayLists that contain ints.  I can construct it just fine, but Processing won't let me get the data back out later.

Simple reproduction of the problem:


ArrayList outerList;

void setup()
{
 outerList = new ArrayList();
 
 for(int i = 0; i < 5; i++)
 {
   ArrayList innerList = new ArrayList();
   for(int j = 0; j < 5; j++)
     innerList.add((int)random(0, 100));
   outerList.add(innerList);
 }
 
 noLoop();
}

void draw()
{
 for(int i = 0; i < outerList.size(); i++)
 {
   print("list #" + nf(i,0) + ": ");
   ArrayList innerList = (ArrayList)(outerList.get(i));
   for(int j = 0; j < innerList.size(); j++)
   {
     int val = (int)innerList.get(j);
     print(nf(val,0) + " ");
   }
   println("");
 }
}

All this code does is construct one of these list-of-lists-of-ints, then attempt to print out the contents.  When I click the run button, I get "Cannot cast from Object to int" on this line:

int val = (int)innerList.get(j);

This has got to be something simple, right?

Smart, NoahBuddy!
Explanation: Processing uses Java 1.5/1.6, so when we put int into an array list, auto-boxing kicks in and puts the int into an Integer. That's one feature of 1.5 we can use without changing syntax! I guess it won't work with 0135 for example.
Alas, since we can't type the ArrayList, it looks like the unboxing doesn't work, so we have to force the cast.

cloister wrote on Mar 31^st, 2009, 10:43am:

It really isn't "lame" there's very good reasons for there being 2 versions. The main one is: speed. The primitive "int" is the thing a processor understands.. it's a set of bits which it can directly address, do maths on and ship around, and so is what you'll use normally. It's not "pure" where everything is an Object, but it is necessary to make things run fast.

But it's not an Object, it has no methods, can't be pointed at by two variables etc, so there's the Object version. And to save every single class ever written to handle generic things have to have 8 extra versions of each method for the 8 primitive types, there are Object types of the primitives, so you only ever need to know how to handle an Object if you don't care what exactly is in it.

So you have the ease of use of an ArrayList, you just have to wrap the int into an Integer

Excuse me, cloister, but I think you are barking at the wrong tree (I find the expression amusing! )
Java is doing unboxing correctly if the array list is typed. As I wrote, the limitation is in Processing, which cannot use 1.5 syntax yet (waiting for somebody to hack the Antlr syntax file to fit P5 needs...).
I wrote a simple class put in a .java file in a Processing sketch:
Code:

import java.util.ArrayList;

class SomeTestClass
{
  ArrayList<Integer> al = new ArrayList<Integer>(10);

  SomeTestClass()
  {
    for (int i = 0; i < 10; i++)
    {
	al.add(i * 10);
    }
  }
  void Print()
  {
    for (int i = 0; i < 10; i++)
    {
	System.out.println(al.get(i) / 5);
    }
  }
}
 

In my sketch, I just do:

SomeTestClass ta = new SomeTestClass();
ta.Print();

And it works fine...