Performance - using JDBC call with 'order by' vs sorting data on app server

Question

Hello! I need some valid thoughts on the performance of using a JDBC call versus processing information on the application server.
Here is the somewhat simplified scenario:
I need to retrieve customer information (name, e-mail, telephone), display it in HTML format and then be able to redisplay it in a different order. For example, initially the list would be displayed sorted by last name, but then a user might choose to sort it by e-mail address. Initial call to DB uses 'order by' in the SQL stmt to get me the initial ordering by last name. Results are stored in 2D array. However, when a user selects a different sort I have two options:
1) just make another call to the DB with a different order by clause. This means I need to create a DB connection, connect to DB, retrieve the results and read them from result set into a 2 dimensional array
2) re-sort data in the 2D array populated during the initial call. This means I need to use java.util.Arrays.sort(my_2D_resultsArray, my_custom_comparator)
Question is : which is more efficient? Number of entries retrieved can be anywhere from 0 to a few thousands (depending on other filters such as customer's country). My feeling is that option umber 2 is better, but I would like to get your opinion.
Thank you!

Answer 1

Good points! Thanks! I ran a test (see code below) and it takes less than a second to sort 2000 Strings and 2000 nulls. The only thing I ran the test at a UNIX prompt as oppose to from within app server (Weblogic). I expect the speed to be compatible though. Do you think that test was valid and tells us that sorting on the app server is probably faster than doing another SQL query?
import java.io.*;
import java.math.*;
import java.util.*;
import java.util.Arrays.*;
public class Test {
  public static void main(String[] args) throws Exception {
    Test test = new Test();
    test.testSortingPerformance();
  public void testSortingPerformance() {
    Object[] objArray2 = new Object[]{};
    Vector v = new Vector();
    Date start, end;
    java.util.Random rd = new java.util.Random(2000);
    for (int i = 0; i < 2000; i++){
      v.add(new Object[]{new String("" + rd.nextInt())});
      v.add(new Object[]{null});
    objArray2 = v.toArray();
    Object[] innerObjArray2 = new Object[]{};
    MyComparator2 myComp = new MyComparator2();
    start = new Date();
    java.util.Arrays.sort(objArray2, myComp);
    end = new Date();
    for (int i = 0; i < objArray2.length; i++) {
      System.out.println();
      innerObjArray2 = (Object[])objArray2;
for (int j = 0; j < innerObjArray2.length; j++) {
System.out.print(innerObjArray2[j] + " ");
System.out.println(v.size());
System.out.println("Start " + start + " End " + end);
import java.util.*;
public class MyComparator2
implements Comparator {
//position in the inner array to use for comparison
private int position = 0;
//default empty constructor
public MyComparator2() {
//implement compare method
public int compare(Object o1, Object o2) {
Object[] strAr1 = (Object[]) o1;
Object[] strAr2 = (Object[]) o2;
if (strAr1[0] == null){
if (strAr2[0] == null){
return 0;
else{
return -1;
else if (strAr2[0] == null){
return 1;
return ( (String) strAr1[0]).compareTo( (String) strAr2[0]);