If the objects are moving, the only way to effectively track distances is... to compute them at the time you need them.

so it works already like that, which isn't hard to do.

How are you currently calculating the distance? PVector, dist, manually...?

From your description, it seems you don't really need the actual distance, but just use it for volume. In that case you could save cpu time on the square root part of the distance calculation (as in: don't do it). Then you only have to adapt the possible incoming range on the max6 side.

If you have a small grid, lookup tables might be an option to pre-calculate all possible distances. However the number of calculations, memory and time increases rapidly as the grid grows (or if you want to calculate for each x, y). For a lot of calculations with a lot of particles, I suppose the more modern solution is to turn to the GPU. For example through GLSL or CUDA. Unfortunately since both are more advanced topics, there is relatively little knowledge available for applying either within Processing.

But before you even consider the options, you might wanna ensure you need optimization in the first place.

Your last row is important.

Below a 1000 particles it shouldn't really be a problem calculating all distances at runtime. Doing additional calculation and especially displaying stuff will impact the frameRate though. But since you mention you are currently going up to 6 objects, it should not be a problem at all.

I've made a quick test sketch with a very basic particle system. One efficiency tip: make sure you are not doublechecking the distances. For example 1-2 and 2-1 are the same. One way to do this, is to check forwards in the list. Or in other words, check against all the particles after the current particle (ID+1 in my basic example). So for example 1-2 will be checked, but 2-1 will not.

In the example sketch I show the ID of both the connected particles, where the checking particle (aka the lowest ID = earlier on the list) is always on top. You can toggle the extra calculation and display stuff with SPACE or set it at the top of the sketch. Without it, you can run 500 particles fast. Without the line display you can run up to a 1000 particles fast. For a crude comparison, when you use something like GLSL or CUDA you could maybe go up to a 1000000 or something.

Code Example

1. import processing.opengl.*;
2.  
3. ArrayList <Particle> flock = new ArrayList <Particle> ();
4. int numParticles = 25;
5. int maxDistance = 150;
6. boolean display = true;
7.  
8. void setup() {
9.   size(800, 800, OPENGL);
10.   textAlign(CENTER, CENTER);
11.   for (int i=0; i<numParticles; i++) {
12.     flock.add(new Particle(i));
13.   }
14. }
15.  
16. void draw() {
17.   background(255);
18.   for (Particle p : flock) {
19.     p.update();
20.     p.display();
21.   }
22.   frame.setTitle(int(frameRate) + " fps");
23. }
24.  
25. void keyPressed() {
26.   if (key == ' ') { display = !display; }
27. }
28.  
29. class Particle {
30.   float x, y, vx, vy;
31.   int ID;
32.  
33.   Particle(int ID) {
34.     this.ID = ID;
35.     x = random(width);
36.     y = random(height);
37.     vx = random(-2, 2);
38.     vy = random(-2, 2);
39.   }
40.  
41.   void update() {
42.     x += vx;
43.     y += vy;
44.     if (x <= 0 || x >= width) { vx = -vx; }
45.     if (y <= 0 || y >= height) { vy = -vy; }
46.   }
47.  
48.   void display() {
49.     // to prevent doublechecking, only compare to the
50.     // particles in the list AFTER the current particle
51.     for (int i=ID+1; i<flock.size(); i++) {
52.       Particle other = flock.get(i);
53.       if (dist(x, y, other.x, other.y) < maxDistance) {
54.         stroke(0);
55.         line(x, y, other.x, other.y);
56.         if (display) {
57.           float xm = lerp(x, other.x, 0.5);
58.           float ym = lerp(y, other.y, 0.5);
59.           fill(255, 0, 0);
60.           noStroke();
61.           ellipse(xm, ym, 40, 40);
62.           fill(0);
63.           text(ID + "\n" + other.ID, xm, ym);
64.         }
65.       }
66.     }
67.     fill(0);
68.     noStroke();
69.     ellipse(x, y, 5, 5);
70.   }
71. }

I'm feeling well because I had intuitively done the thing to avoid checking twice the same distance.