If I understand you correctly you have 10 incoming measurements, let's call these measure1, measure 2 etc. I am assuming at the end of the program you have a whole range of values for each measure and you want to sort these values per measure. That means sorting all the values that came in for measure1 against each other etc.

If I have understood your purpose correctly, then I would say that using an Arraylist is easier.

Pseudo-code Example

1. ArrayList <Float> measure1 = new ArrayList <Float> ();
2. ...
3. // add the value to the arraylist every time a new one comes in
   
4. measure1.add(incomingValueForMeasure1);
5. ...
6. // at the end of the program sort the whole list
   
7. Collections.sort(measure1)

Why use ArrayList instead of array with append()?

With a little class, it will help keeping the values together:

1. class Measure
2. {
3.   int sensorNb;
4.   float value;
5.   Measure(int id, float v)
6.   {
7.     sensorNb = id;
8.     value = v;
9.   }
10. }

(see also From several variables to arrays )
ArrayList<Measure> measures = new ArrayList<Measure>();

When getting a measure:
measures.add(new Measure(1, 5.0));
for example.

To sort all this... Well, I prefer to show the whole test code. The sorting incantation can seem cryptic, but it isn't that complex, really...

class Measure
{
  int sensorNb;
  float value;
  Measure(int id, float v)
  {
    sensorNb = id;
    value = v;
  }
  
  public String toString()
  {
    return "M[" + sensorNb + "] = " + value;
  }
}
ArrayList<Measure> measures = new ArrayList<Measure>();
 
void setup()
{
  measures.add(new Measure(1, 5.0));
  measures.add(new Measure(3, 15.0));
  measures.add(new Measure(2, 7.0));
  measures.add(new Measure(5, 11.0));
  measures.add(new Measure(4, 9.0));
  
  println(measures);
  
  Collections.sort(measures, new Comparator<Measure>()
  {
    public int compare(Measure m1, Measure m2)
    {
      if (m1.value < m2.value) return -1;
      if (m1.value > m2.value) return 1;
      return 0;
    }
  });
  
  println(measures);

  exit();
}

Thanks PhiLho, absolutely brilliant!
I've implemented you code and can now sort the wind and temp values ascending and descending (using Collections.reverse). I can now do this for one of the five sensors but eventually I'll need to do this for all 5 sensors and for all of them store an average of highest and lowest value.
I think the nicest way would be to sort a subset and then find the highest and lowest average for each set and store these in a float variable. The subset would of course be all the values of one sensor. Is this the way to go?
I've been looking at the Java Collections class but I don't see a way to do this.

Can someone tell me if I should work with subsets and if so can tell me to go about this?
Or can someone suggest a better way of tackling this?

Thanks very much in advance for your thoughts and suggestions, best, d

Using Collection.reverse is smart. Perhaps not very efficient, but for small collections, it doesn't matter.
Alternatively (for the record), you can just invert the result of compare()...
Just for fun, here is a new version of the above code. A bit more advanced, but again, not that hard (I hope).

void setup()
{
  measures.add(new Measure(1, 5.0));
  measures.add(new Measure(3, 15.0));
  measures.add(new Measure(2, 7.0));
  measures.add(new Measure(5, 11.0));
  measures.add(new Measure(4, 9.0));
  
  println(measures);
  
  Collections.sort(measures, new CompareMeasures(false));
  println(measures);
  
  Collections.sort(measures, new CompareMeasures(true));
  println(measures);

  exit();
}

class CompareMeasures implements Comparator<Measure>
{
  int sortOrder = 1;
  
  CompareMeasures(boolean bReverse)
  {
    if (bReverse) sortOrder = -1;
  }
  
  //@Override
  public int compare(Measure m1, Measure m2)
  {
    if (m1.value < m2.value) return -sortOrder;
    if (m1.value > m2.value) return sortOrder;
    return 0;
  }
}

(class definition unchanged)
You can make an array of array lists, since you have a known number of sensors:

ArrayList<Measure>[] measures = new ArrayList[5];
 
void setup()
{
  for (int i = 0; i< measures.length; i++)
  {
    measures[i] = new ArrayList<Measure>();
  }
  
  measures[0].add(new Measure(1, 5.0));
  measures[0].add(new Measure(3, 15.0));
  measures[0].add(new Measure(2, 7.0));
  measures[0].add(new Measure(5, 11.0));
  measures[0].add(new Measure(4, 9.0));
  
  measures[1].add(new Measure(1, 115.0));
  measures[1].add(new Measure(5, 125.0));
  measures[1].add(new Measure(3, 117.0));
  measures[1].add(new Measure(4, 119.0));
  measures[1].add(new Measure(2, 99.0));
  
  println(measures[0]);
  println(measures[1]);
  
  Collections.sort(measures[0], new CompareMeasures(false));
  println(measures[0]);
  
  Collections.sort(measures[1], new CompareMeasures(true));
  println(measures[1]);

  exit();
}

And so on.
So, yes, you can sort each set of measures, get first and last items and average them (one by one, in a loop).

Attempt at array only:

sensor[1][3]
represents one sensor.
accessed by sensor[0][0] = sensor_number, sensor[0][1] = value1, sensor[0][2] = value2
By having sensor_number in there we can swap sensor[m][0,1,2] with sensor[n][0,1,2] to do a sort.
To print the sensors and values from five sensors sensor[5][3]
for i  = 0 to 4
 print "Sensor #"+sensor[i][0]
 print "Value 1"+sensor[i][1]
 print "Value 2"+sensor[i][2]

If the code in the previous post looks at all complicated it is actually a beautiful solution to what happens when you are bombarded with requests for more sensors and flexibility. Sometimes going with an array keeps code easy other times code keeps arrays representing groups elegant.

Indeed, there are often several solutions to a given problem.
If the purpose is to get max and min values of an array, there is actually no need to sort: a simple loop and two values to compare with each value of the array is enough.
And if sorting is really necessary, and the number of values is low, a simple bubble sort can do the job, indeed.

Hi all,

Thanks for your replies.
@teddybot, the reason PhiLho suggested the object to work with was because the values are a mixture of ints and floats.
@PhiLho, thanks so very much for your code. I love it. I tried a reverse (true) on the same arrayList after I did a normal sort (false) but I got an index out of bounds error. So I swapped back to you first suggestion and used Collection.reverse again.
 
Everything seems to work fine, I get 5 arrayLists and I can sort and reverse them. But now when I try to get the avarage of the highest and lowest 50 values (calOffset in the code below) of all 5 sensors things stop working. I'm probably overlooking some basic things here, hope someone can point them out to me. This is the code in the draw function on which no frameRate has been set.

1. void draw() {
2. // get string from serial //////////////////////////////////////
3.    String inString = myPort.readStringUntil('\n');
4.    if (inString != null) {
5.      // trim off any whitespace:
6.      inString = trim(inString);
7.      //print("in string: ");
8.      //println(inString);
9.      float[] wt_array = float(split(inString, ","));
10.      // check for all values
11.      if(wt_array.length >= 2){
12.        // convert to an int and map to the screen height:
13.        sWind = wt_array[0];
14.        // map wind
15.        newStr = str(sWind);
16.        newStr = newStr + ", ";
17.        sTemp = wt_array[1];
18.        newStr = newStr + str(sTemp);
19.        b_data = append(b_data, newStr);
20.        //println(newStr);
21.      }
22.    } // end inString
23.    // loop all sensors ///////////////////////////////////////////
24.    for(int j=0; j<5; j++){
25.     if(callibrating == true){
26.       background(0);
27.       // count down
28.      if((millis()-calTime)<startTime){
29.        if(j==0){
30.            allWindCalVals[j].add(new Calibration(j, wind0));
31.            allTempCalVals[j].add(new Calibration(j, temp0));
32.        }
33.        if(j==1){
34.            allWindCalVals[j].add(new Calibration(j, wind1));
35.            allTempCalVals[j].add(new Calibration(j, temp1));
36.        }
37.        if(j==2){
38.            allWindCalVals[j].add(new Calibration(j, wind2));
39.            allTempCalVals[j].add(new Calibration(j, temp2));
40.        }
41.        if(j==3){
42.            allWindCalVals[j].add(new Calibration(j, wind3));
43.            allTempCalVals[j].add(new Calibration(j, temp3));
44.        }
45.        if(j==4){
46.            allWindCalVals[j].add(new Calibration(j, wind4));
47.            allTempCalVals[j].add(new Calibration(j, temp4));
48.        }  
49.       } // end timer
50.       else{
51.          println("stop timer ########################################################");
52.          // calculate ofset settings
53.          callibrating = false;
54.          int i = 0;
55.          background(255);
56.          for(int k=0; k<5; k++){
57.            print("k:");
58.            println(k); 
59.            // wind //////////////////////////////////////////////////////////////////
60.            Collections.sort(allWindCalVals[k], new Comparator<Calibration>()
61.             {
62.               public int compare(Calibration m1, Calibration m2)
63.               {
64.                 //sort ASC
65.                 if (m1.value < m2.value) return -1;
66.                 if (m1.value > m2.value) return 1;
67.                 return 0;
68.               }
69.             });
70.             //println("whole array:");
71.             //println(allWindCalVals[k]);
72.              for(Calibration c: allWindCalVals[k]){
73.                if(i<calOffset){
74.                  w_idleVals[k] += c.value;
75.                  i++;
76.                }
77.              }
78.              w_idleVals[k] = w_idleVals[k]/calOffset;
79.              //println(w_idleVals[k]);
80.              print("idle vals: ");
81.              println(w_idleVals);
82.              //sort DESC
83.              Collections.reverse(allWindCalVals[k]);
84.              i = 0;
85.              for(Calibration c: allWindCalVals[k]){
86.                if(i<calOffset){
87.                  w_inVals[k] += c.value;
88.                  i++;
89.                }
90.              }
91.              w_inVals[k] = w_inVals[k]/calOffset;
92.      
93.          } // end k for loop
94.        } // end else calibrating 
95.      } // end calibrating true
96.    } // end big for loop sensors
97. //  println("sensor 4");
98. //  println(allWindCalVals[4]);
99. //  print("len: ");
100. //  println(allWindCalVals[4].size());
101. } // end draw

As you can see in line 24 I have one big for loop that loops through all 5 sensors. It fill all 5 allWindCalVals arrayLists with the right values. So far so good.
I was expecting the loop to continue looping, as it is in the draw() function but after the timer has stopped in line 49 and I want to use j again in the next else block it stays at 0.
So I've introduced another loop to calculate the averages on line 56. The k variable is incremented al right but the averages are not calculated, they stay 0.0. But I know the arrayLists have been filled with the right data, because I've tested that in line 98 for example.
Here is the output of the above code:
stop timer ########################################################
k:0
idle vals: [0] 119.46
[1] 0.0
[2] 0.0
[3] 0.0
[4] 0.0
k:1
idle vals: [0] 119.46
[1] 0.0
[2] 0.0
[3] 0.0
[4] 0.0
k:2
idle vals: [0] 119.46
[1] 0.0
[2] 0.0
[3] 0.0
[4] 0.0
k:3
idle vals: [0] 119.46
[1] 0.0
[2] 0.0
[3] 0.0
[4] 0.0
k:4
idle vals: [0] 119.46
[1] 0.0
[2] 0.0
[3] 0.0
[4] 0.0

Why aren't items 1 to 4 set in w_idleVals[k]? Thanks ever so much for you time and help, best, d

Beware of w_idleVals[k]/calOffset. If you divide an integer by an integer, the result is an integer, which can be zero if the divider is bigger than the divided part.
And you should do all the additions before doing the division...

Thanks again PhiLho.
The looping was just all wrong and data was overwritten. This is the working version:

1. void draw() {
2. // get string from serial //////////////////////////////////////
3.    String inString = myPort.readStringUntil('\n');
4.    if (inString != null) {
5.      // trim off any whitespace:
6.      inString = trim(inString);
7.      //print("in string: ");
8.      //println(inString);
9.      float[] wt_array = float(split(inString, ","));
10.      // check for all values
11.      if(wt_array.length >= 2){
12.        // convert to an int and map to the screen height:
13.        sWind = wt_array[0];
14.        // map wind
15.        newStr = str(sWind);
16.        newStr = newStr + ", ";
17.        sTemp = wt_array[1];
18.        newStr = newStr + str(sTemp);
19.        b_data = append(b_data, newStr);
20.        //println(newStr);
21.      }
22.    } // end inString
23.     if(callibrating == true){
24.       background(0);
25.       // count down
26.      if((millis()-calTime)<startTime){
27.        // loop all sensors ///////////////////////////////////////////
28.        for(int j=0; j<5; j++){
29.          if(j==0){
30.              allWindCalVals[j].add(new Calibration(j, windArray[j]));
31.              allTempCalVals[j].add(new Calibration(j, tempArray[j]));
32.          }
33.          if(j==1){
34.              allWindCalVals[j].add(new Calibration(j, windArray[j]));
35.              allTempCalVals[j].add(new Calibration(j, tempArray[j]));
36.          }
37.          if(j==2){
38.              allWindCalVals[j].add(new Calibration(j, windArray[j]));
39.              allTempCalVals[j].add(new Calibration(j, tempArray[j]));
40.          }
41.          if(j==3){
42.              allWindCalVals[j].add(new Calibration(j, windArray[j]));
43.              allTempCalVals[j].add(new Calibration(j, tempArray[j]));
44.          }
45.          if(j==4){
46.              allWindCalVals[j].add(new Calibration(j, windArray[j]));
47.              allTempCalVals[j].add(new Calibration(j, tempArray[j]));
48.          }
49.        } // end big for loop sensors  
50.       } // end timer
51.       else{
52.          // calculate ofset settings
53.          callibrating = false;
54.          int i = 0;
55.          background(255);
56.          for(int k=0; k<5; k++){
57.            if(k==0){
58.              setCalibrationVals(k);
59.            }
60.            if(k==1){
61.              setCalibrationVals(k);
62.            }
63.            if(k==2){
64.              setCalibrationVals(k);
65.            }
66.            if(k==3){
67.              setCalibrationVals(k);
68.            }
69.            if(k==4){
70.              setCalibrationVals(k);
71.            }
72.          } // end k for loop
73.        } // end else calibrating 
74.      } // end calibrating true
75. } // end draw

For those of you interested: I split the whole thing up into two separate loops (i and k). The i loop collecting the data and the k loop doing the sorting. I wanted to reuse the code for the sorting (that was my motive for using a loop anyway) so now from the k loop I just call a function with the sorting code (above) passing the sensor number to that function. Now every sensor gets it's values nicely one after another.
Thanks again for all your help, best, d

I'm coming to this quite late but the if statements in those for loops look to be completely unnecessary.  The following is functionally identical and getting on for 40 lines shorter.

1. void draw() {
2. // get string from serial //////////////////////////////////////
3.    String inString = myPort.readStringUntil('\n');
4.    if (inString != null) {
5.      // trim off any whitespace:
6.      inString = trim(inString);
7.      //print("in string: ");
8.      //println(inString);
9.      float[] wt_array = float(split(inString, ","));
10.      // check for all values
11.      if(wt_array.length >= 2){
12.        // convert to an int and map to the screen height:
13.        sWind = wt_array[0];
14.        // map wind
15.        newStr = str(sWind);
16.        newStr = newStr + ", ";
17.        sTemp = wt_array[1];
18.        newStr = newStr + str(sTemp);
19.        b_data = append(b_data, newStr);
20.        //println(newStr);
21.      }
22.    } // end inString
23.     if(callibrating == true){
24.       background(0);
25.       // count down
26.      if((millis()-calTime)<startTime){
27.        // loop all sensors ///////////////////////////////////////////
28.        for(int j=0; j<5; j++){
29.          allWindCalVals[j].add(new Calibration(j, windArray[j]));
30.          allTempCalVals[j].add(new Calibration(j, tempArray[j]));
31.        } // end big for loop sensors  
32.       } // end timer
33.       else{
34.          // calculate ofset settings
35.          callibrating = false;
36.          int i = 0;
37.          background(255);
38.          for(int k=0; k<5; k++){
39.              setCalibrationVals(k);
40.          } // end k for loop
41.        } // end else calibrating 
42.      } // end calibrating true
43. } // end draw