Java Sorting a 2d array rows into ascending and columns into descending order

int[] colArray = new int[] { 2, 9, 4, 5};
int n = colArray.length;
int temp = 0;


for (int i = 0; i < n; i++) {
  for (int j = 1; j < (n - i); j++) {

      if (colArray[j - 1] > colArray[j]) {
          temp = colArray[j - 1];
          colArray[j - 1] = colArray[j];
          colArray[j] = temp;
      }

  }
 }
 Arrays.stream(colArray).forEach(data -> System.out.println(data));

Just replace

if (colArray[j - 1] < colArray[j]) {
...
}

with:

if (colArray[j - 1] > colArray[j]) {
...
}

> instead of <

First of all your array is not 2D :) , just because each elemnt of array has a number to be called like Arr[0] and its value is e.g 5 it doesnt mean its 2D.

but in order to sort your array into descending order you can use code below :

            int n = intArray.length;
            int temp = 0;

            for(int i=0; i < n; i++){
                    for(int j=1; j < (n-i); j++){

                            if(intArray[j-1] < intArray[j]){
                                    //swap the elements!
                                    temp = intArray[j-1];
                                    intArray[j-1] = intArray[j];
                                    intArray[j] = temp;
                            }

                    }
            }

I rewrote your sortSort method to sort the columns. Though this shouldn't be the solution, but rather point you in the right direction.

This is how I imagine a 2D-array:

 _ _ _ _ _
|_|_|_|_|_|
|_|_|_|_|_|
|_|_|_|_|_| <rows
 ^
 cols

In code I would look at it this way: myArray[row][col]

But more precisely its an array of arrays, so actually it looks more like this:

 ______________ ______________ ______________
|  _ _ _ _ _   |  _ _ _ _ _   |  _ _ _ _ _   |
| |_|_|_|_|_|  | |_|_|_|_|_|  | |_|_|_|_|_|  |
|______________|______________|______________|
      ^              ^              ^
     row 0          row 1          row 2     

Each row contains an array of columns. And that's the problem - you cannot compare the array of row 0 with the array of row 1 and say which array one is "greater" ... unless you sort it by it's size.

In your program you called your column sorting method like this:

//Print out sorted columns of array
for (int i = 0; i < sortArray.length; i++) {
    sortSort(sortArray[i]);
}

The index i iterates over the rows and calls sortSort. So for i=0 it takes the first row and passes the containing array of columns to sortSort. Thus your method can only sort the columns of a single row.

sortSort(sortArray[i]);  // sortArray[i] represents all columns of row i

To make it sort the columns, it must be aware of the whole 2D-array. Columns and rows. Meaning you can only sort the whole array at once but not single columns.

Let's look at it in my example:

public static void sortSort(int[][] colArray) {  // we pass the whole 2D-array int[rows][cols]
    int n = colArray.length;    
    int temp = 0;

    // since every row contains a whole array, you cannot really sort the row itself.
    // But you can sort it by its columns value (confusing, I know - sorry)
    // we take the first row as reference (colArray[0])
    // and iterate over every column (from 0 to colArray[0].length)
    // that's a problem, but we get to that later
    for (int col = 0; col < colArray[0].length; col ++) {
        // your sorting loops are working, so we don't change them
        for (int i = 0; i < n; i++) {
            for (int j = 1; j < (n - i); j++) {
                // and here is the magic we compare row j with row j-1 of the current column (col)
                if (colArray[j - 1][col] < colArray[j][col]) {
                    temp = colArray[j - 1][col];
                    colArray[j - 1][col] = colArray[j][col];
                    colArray[j][col] = temp;
                }
            }
        }
    }
}

You can test this code and see that it works. However it can only work under certain circumstances!

The problem I mentioned earlier is that every row needs the exact same number of columns as the first:

This wouldn't work:
 _ _ _ _ 
|_|_|_|_|       <-- row 1 has 4 columns
|_|_|_|_ _ _    <-- row 2 only 3
|_|_|_|_|_|_|   <-- row 3 has 6 columns

If you don't have to make this work for a variable number of columns - leave it be. If you always have a nice table of n rows with each m columns, the above method does the trick.