1. for (int a = 0; a < balls ; a++) {
2.   for (int b = a + 1; b < balls ; b++) {
3.     // draw line between a and b?
4.   }
5. }

1. if(loc.x != other.loc.x){

maybe add a parameter to the method?

1. void lineBetween(int startIndex){
2. for (int i = startIndex; i < ballCollection.size(); i++){
3. ...
   

1. for (int a = 0 ; a < ballCollection.size ; a++) {
2.       ball = ballCollection.get(a);
3.       ball.lineBetween(a + 1); // your method with new parameter
4. }

1. Balls gBalls;
2. int gMinDistance = 100;
3. // -------------------------------------------------------------------------------
4. void setup(){
5.   gBalls = new Balls();
6. 
   
7.   gBalls.addBall(400, 300, int(random(50)));
8.   gBalls.addBall(400, 300, int(random(50)));
9.   gBalls.addBall(400, 300, int(random(50)));
10.   gBalls.addBall(400, 300, int(random(50)));
11.   gBalls.addBall(400, 300, int(random(50)));
12.   gBalls.addBall(400, 300, int(random(50)));
13.   gBalls.addBall(400, 300, int(random(50)));
14.   gBalls.addBall(400, 300, int(random(50)));
15.   gBalls.addBall(400, 300, int(random(50)));
16.   gBalls.addBall(400, 300, int(random(50)));
17.   gBalls.addBall(400, 300, int(random(50)));
18.   gBalls.addBall(400, 300, int(random(50)));
    
19. 
    
20.   size(800, 600);
21. }
22. // -------------------------------------------------------------------------------
23. void draw(){
24.   background(255);
25.   gBalls.update();
    
26. }
27. // -------------------------------------------------------------------------------
28. public class Ball{
29.       protected float mX, mY, mR;
30.       protected float mVectorX = 0;
31.       protected float mVectorY = 0;
32. 
    
33.       public Ball(int x, int y, int r){
    
34.             mX = x;
35.             mY = y;
    
36.             mR = r;
    
37.             while(mVectorX == 0){
38.                   mVectorX = random(-5, 5);
39.             }
    
40.             while(mVectorY == 0){
41.                   mVectorY = random(-5, 5);
42.             }
43.       }
    
44.       // -------------------------------------------------------------------------------
45.       public void update(){
46.             ellipse(mX + mVectorX, mY + mVectorY, mR, mR);
47.       }
    
48.       // -------------------------------------------------------------------------------
49.       public void setPosition(){
50.             mX = mX + mVectorX;
51.             if (mX < 0){
52.                   mVectorX = mVectorX * -1;
53.             }
    
54.             if (mX > 800){
55.                   mVectorX = mVectorX * -1;
56.             }
57.             mY = mY + mVectorY;
58.             if (mY < 0){
59.                   mVectorY = mVectorY * -1;
60.             }
    
61.             if (mY > 600){
62.                   mVectorY = mVectorY * -1;
63.             }
    
64.       }
65. }
    
66. // -------------------------------------------------------------------------------
67. public class Balls{
68.       protected ArrayList<Ball> mBalls = new ArrayList<Ball>();
69.       public Balls(){
70.       }
71.       // -------------------------------------------------------------------------------
72.       public void update(){
73.             for(Ball b : mBalls){
74.                   b.setPosition();
75.                   b.update();
76.             }
77.             drawLines();
78.       }
    
79.       // -------------------------------------------------------------------------------
80.       public void drawLines(){
81.             for(int i = 0; i < mBalls.size(); i++){
82.                   Ball b1 = (Ball) mBalls.get(i);
83.                   for(int j = i + 1; j < mBalls.size(); j++){
84.                         Ball b2 = (Ball) mBalls.get(j);
85.                         drawLine(b1, b2);
86.                   }
    
87.             }
    
88.       }
89.       // -------------------------------------------------------------------------------
90.       public void drawLine(Ball b1, Ball b2){
91.             if (nearEnough(b1, b2)){
92.                   line(b1.mX + b1.mVectorX, b1.mY + b1.mVectorY, b2.mX + b2.mVectorX, b2.mY + b2.mVectorY);
93.             }
    
94.       }
95.       // -------------------------------------------------------------------------------
96.       public boolean nearEnough(Ball b1, Ball b2){
97.             float a = b1.mX - b2.mX;
98.             float b = b1.mY - b2.mY;
99.             return(sqrt(pow(a, 2) + pow(b, 2)) < gMinDistance);
100.       }
101.       public void addBall(int x, int y, int r){
102.             Ball b = new Ball(x, y, r);
103.             mBalls.add(b);
104.       }
105. }