It is hard to tell out of the blue. But as the structure is described, I doubt it is the source of contention. Perhaps it is your display method which is to improve.

I was curious, so I made a little experiment.
I found out that using CircularFifoBuffer is as fast as using a simple array.
In my first attempt, I had lot of slow downs because of frequent "stop the world" garbage collections. Lot of garbage was created, making high peak memory usage, even if the low memory consumption was reasonable.
I found out this garbage was actually created by the Java2D display! I suppose that it creates objects for each color assignment, for each ellipse drawn, etc.
As soon as I switched to P2D (in Processing 1.5, ie. still the old direct pixel manipulation way), I had nearly no garbage generated (beside the ball creation) and no slowdowns nor halts. From around 15 fps to around 55 fps!
Screenshots from JVisualVM:

With Java2D


With P2D

I don't know if my findings applies to your case, as you don't give details, but it is an interesting test.
Ah, I almost forgot the code:

1. import org.apache.commons.collections.buffer.*;
2.  
3. boolean bUseFifo = true;
4. boolean bDynamicArray = true;
5. final int SIZE = 2000;
6. CircularFifoBuffer buffer;
7. Ball[] balls;
8.  
9. void setup()
10. {
11.   size(800, 800, P2D);
12.   if (bUseFifo)
13.   {
14.     buffer = new CircularFifoBuffer(SIZE);
15.   }
16.   else
17.   {
18.     balls = new Ball[SIZE];
19.     for (int i = 0; i < SIZE; i++)
20.     {
21.       balls[i] = new Ball();
22.     }
23.   }
24. }
25.  
26. void draw()
27. {
28.   background(255);
29.   if (bUseFifo)
30.   {
31.     for (int i = 0; i < SIZE / 20; i++)
32.     {
33.       Ball b = new Ball();
34.       buffer.add(b);
35.     }
36.     for (Iterator it = buffer.iterator(); it.hasNext(); )
37.     {
38.       Ball b = (Ball) it.next();
39.       b.display();
40.     }
41.   }
42.   else
43.   {
44.     if (bDynamicArray)
45.     {
46.     for (int i = 0; i < SIZE / 20; i++)
47.     {
48.       Ball b = new Ball();
49.       balls[int(random(SIZE))] = b;
50.     }
51.     }
52.     for (int i = 0; i < SIZE; i++)
53.     {
54.       Ball b = balls[i];
55.       b.display();
56.     }
57.   }
58.   fill(0);
59.   text("FC: " + frameRate, 10, 20);
60. }
61.  
62. class Ball
63. {
64.   int x, y, s;
65.   color c;
66.  
67.   Ball()
68.   {
69.     x = int(random(width));
70.     y = int(random(height));
71.     s = int(random(5, 20));
72.     c = color(random(50, 100), random(255), random(255), random(128, 200));
73.   }
74.   
75.   void display()
76.   {
77.     noStroke();
78.     fill(c);
79.     ellipse(x, y, s, s);
80.   }
81. }

Great great work.  Thank you for the replies.  Because of requirements with other libraries I'm using ( Unfolding), I'm having to render with GLGRAPHICS, so maybe that's causing a similar bottleneck.  I'll have to experiment.