This is a bit of blind advice since I can't find the docs for JSON.getArray() at either of the following:

" Processing may not be aware that the thing being returned with getArray() is an array"
Sorry, but that's non-sense.

" JSON functionality integrated in the processing now, but where I can read about them"
http://processing.org/reference/javadoc/core/
See the processing.data package.
Official since 2.0b9 (at least?).

having the link to the processing javadocs sheds light on a possibility, namely, that I cannot find getArray() as a function of the JSON object.  There is however getStringArray, so perhaps that is what is causing the issue.

as an aside, my original suggestion is not non-sense.  now.  it might not be the case that my suggestion is the solution to this particular problem, but unless you know all things, it is also not the case that it is "non-sense" just because it does not "make-sense" to you. 

it's happened to me before and that's how i know about it.  i may have worded it improperly so I'll give it another shot: suppose you have an object of class Zoo and the Zoo class has a property that is an array of class type Animals.  In some instances, trying to perform an array operation on that property through chaining will not work.  Instead you may have to "pull it out" into a variable declared as an Animal array, or "class cast" it first (can't recall the exact syntax of class casting).

in the future, it is more constructive to say "can you tell me more about why you think that?".  then i can say "sure, here's why i think so".  then you can say "i don't think that is the case, and here's why it's not".  if you'd like you can skip the first two and go straight to, "i don't think so, here's why".  the important difference is the "here's why".  then at least one of us will learn something as a result of having discussed it, maybe even both of us. [happy emoticon face].  we'll look back on it and laugh about it and i'll say, "oh man, can you believe that thing I thought?! that was such non-sense, how funny that time was!".  and you will say "it was funny, you are the most nonsensical. that was the best of times!"

i'd welcome the opportunity to understand why i'm wrong because it will strengthen my model of how Processing works enabling me to give even better advice in the future.

" trying to perform an array operation on that property through chaining will not work.  Instead you may have to "pull it out" into a variable declared as an Animal array"
OK, if you prefer, that's just plain false.
Perhaps you have meet a problem that was puzzling for you, and you found a workaround, but in general, you can just chain methods in Java. No need to extract the information in an intermediary variable. You can even cast and chain at the same time:
((Foo) someObject).methodOfFooOnly();
If the method happens to return an object of proper type, you can even chain several calls (that's called fluid API):
foo.setX(5).setY(10);
for example. Not working if methods are void, of course.

My terseness was perhaps kind of offending, but it was not my intention, so sorry if you saw it as such. I was in a hurry when I wrote that, but I prefer to avoid false conceptions about the language to be spread.

[EDIT] Perhaps you used untyped array lists: you cannot use get() directly on objects taken from them, because they are given as Object, the most generic type of Java, without the methods you want:

1. ArrayList list = new ArrayList(); // You can put anything into it!
   
2. list.add(new SomeClass());
3. // You cannot do that:
4. list.get(0).someClassMethod();
5. // Usually, people do that:
6. SomeClass sc = (SomeClass ) list.get(0);
7. sc.someClassMethod();
8. // But as shown, you can also do that:
9. ((SomeClass) list.get(0)).someClassMethod();

Not nice, but it works.
But a better way is to use the syntax introduced in Java 1.5 (a long time ago, but you still find lot of untyped example on Internet, and Procesisng was slow to allow this syntax).

1. ArrayList<SomeClass> list = new ArrayList<SomeClass>(); // You can put only SomeClass in it
   
2. list.add(new SomeClass());
3. // You can do that now!
   
4. list.get(0).someClassMethod();

honestly, how you say it only matters to my ego which spews it's own non-sense at times, and in reality is not your responsibility to coddle; so there's work for me to do there.  what matters most to me is chaining it with a function that returns a "why" (har har), which is the most effective way to prevent the spreading false misconceptions.

thanks for the explanation callback!

funny funny funny.

if i recall correctly (and i think i do) it was exactly an arrayList.

i was a beginner than and i knew very little about actual Java which can be frustrating to beginners because every so often you have to use it.

thanks!  it's great to know the limits of what something you've discovered out of context actually applies to.

man.  i sure hope the project sr.richie was working on was for world peace or curing a disease because we have worked it!