Java - Sort an Array Twice?

Use an object ZipCode like this:

public class ZipCode{

    private String zipcode;
    private ArrayList<String> adds

    public ZipCode(String zip){
        zipcode = zip;
        adds = new ArrayList<String>();
    }

    public void addAddress(String address){
        adds.add(address);
        Collections.sort(adds);
    }

}

Keep an array of ZipCodes sorting them necessarily:

ZipCode[] zips = . . . 
  .
  .
  .
Arrays.sort(zips);

First of all, are you aware that Java provides a more efficient sorting mechanism out of the box? Check the Arrays class.

Secondly you have to be very careful with your approach. What you are doing here is swapping all the elements of one row with the other. But you are not doing the same thing within each row. So you need a separate nested loop outside the current while (before or after, doesn't make a difference), which checks the houses themselves and sorts them:

   for ( k = 0; k < Row; k++)
   {
     do
     {
       DidISwap = false;

       for ( m = 0; m < Col-1; m++)
       {
         if (Numbers[k][m] > Numbers[k][m+1])
         {
           Hide = Numbers[k][m];
           Numbers[k][m] = Numbers[k][m+1];
           Numbers[k][m+1] = Hide;
           DidISwap = true;
         }
       }
     }
     while (DidISwap);
   } 

However, your approach is very inefficient. Why don't you put the list of houses in a SortedSet, and then create a SortedMap which maps from your postcodes to your Sorted Sets of houses? Everything will be sorted automatically and much more efficiently.

You can use the TreeMap for your SortedMap implementation and the TreeSet for your SortedSet implementation.

I / we could try to tell you how to fix (sort of) your code to do what you want, but it would be counter-productive. Instead, I'm going to explain "the Java way" of doing these things, which (if you follow it) will make you more productive, and make your code more maintainable.

1. Follow the Java style conventions. In particular, the identifier conventions. Method names and variable names should always start with a lower case character. (And try to use class, method and variable names that hint as to the meaning of the class/method/variable.)

2. Learn the Java APIs and use existing standard library classes and methods in preference to reinventing the wheel. For instance:

   • The Arrays and Collections classes have standard methods for sorting arrays and collections.

   • There are collection types that implement sets and mappings and the like that can take care of "boring" things like keeping elements in order.

3. If you have a complicated data structure, build it out of existing collection types and custom classes. Don't try and represent it as arrays of numbers. Successful Java programmers use high-level design and implementation abstractions. Your approach is like trying to build a multi-storey car-park from hand-made bricks.

My advice would be to get a text book on object-oriented programming (in Java) and get your head around the right way to design and write Java programs. Investing the effort now will make you more productive.