Sorting rows of a 2d integer array from smallest to biggest

arry[indexSmallest][0] = 2147483647;

This line of code is setting the first element in each row to 2147483647 at the end of your outermost for loop. This is why it appears in each row. I'm not sure what you intended to do here, but this is why you are getting that value.

Remember, Java arrays are objects, which means they are passed by reference. So you're not actually making a copy of the inner arrays; use Arrays.copyOf() for that.

If you're allowed to use Arrays.sort() with a Comparator, you could do it like this.

java.util.Arrays.sort(arry, new java.util.Comparator<int[]>() {
    public int compare(int[] a1, int[] a2) {
        for (int k = 0; k < a1.length; k++) {
            if (a1[k] != a2[k]) {
                return a1[k] - a2[k];
            }
        }
        return 0;
    }
});
for (int k = 0; k < numOfArrays; k++) {
    System.out.println(java.util.Arrays.toString(arry[k]));
}

If that's not allowed, then you can still use the comparison logic inside the above Comparator.compare() method. That's your basic sorting logic regardless of the implementation details.

You have make this info inside of an Object and implement Comparable/Comparator:

public YourObject implements Comparable {
    private long a;
    private long b;
    private long c;

    public YourObject (long a, long b, long c){
         this.a = a;
         this.b = b;
         this.c = c;
    }

    public int compareTo(Object arg0) {
        //make your comparison here...
    }

}

In main function: YourObject[] arr = new YourObject[3]; arr[0] = new YourObject (.., .., ..,); arr[1] = new YourObject (.., .., ..,); arr[2] = new YourObject (.., .., ..,);

Arrays.sort(arr); //sorting your data

_{You can greatly simplify your code by using Arrays.sort method, or otherwise you can implement something like this.}

Selection sort of a 2d array by column

public static void selectionSort2D(int[][] arr, int column) {
    // iterate over all subsets of the rows of the array
    // (0-last, 1-last, 2-last, 3-last, ...)
    for (int i = 0; i < arr.length; i++) {
        // assume the min is the first row element
        int min = arr[i][column];
        // row index of the min element
        int min_i = i;
        // check the rows after i to find the smallest
        for (int j = i + 1; j < arr.length; j++) {
            // if this row element is less,
            // then it is the new min
            if (arr[j][column] < min) {
                min = arr[j][column];
                min_i = j;
            }
        }
        // if the min element row is not equal to
        // the current one, then swap these rows
        if (i != min_i) {
            int[] temp = arr[i];
            arr[i] = arr[min_i];
            arr[min_i] = temp;
        }
    }
}

// test
public static void main(String[] args) {
    int[][] arr = {
            {6, 2, 7},
            {3, 6, 7},
            {5, 6, 1},
            {5, 3, 4},
            {5, 3, 8}};

    // sort by first column
    selectionSort2D(arr, 0);

    // output
    for (int[] row : arr)
        System.out.println(Arrays.toString(row));
    //[3, 6, 7]
    //[5, 6, 1]
    //[5, 3, 4]
    //[5, 3, 8]
    //[6, 2, 7]
}