Sort 2D array by average value of each line

The part of your code that calculates the average:

    float[] arrayAverage = new float[array1stDsize];
    float average = 0;
    for (int i = 0; i < array.length; i = i + 1) {
        for (int j = 0; j < array[i].length; j = j + 1) {
            average = average + array[i][j];
        }
        average = (float) (Math.round((average / array[i].length) * 100.0) / 100.0);
        System.out.println(i + ". array average value: " + average);
        arrayAverage[i] = average;
    }

is slightly wrong, you need to set the average variable to zero before calculating the average of the next rows:

  ...
  arrayAverage[i] = average;
  average = 0;

With the Java Streams one can get the matrix sorted by average of rows pretty elegantly, namely:

Arrays.sort(array, comparingDouble(row -> IntStream.of(row)
                                                   .average()
                                                   .getAsDouble()));

To sort the array one uses the method Arrays.sort, and then for each row one gets its average as a double value IntStream.of(row).average().getAsDouble(), and used as the sorting parameter comparingDouble(....).

A running example:

import java.util.Arrays;
import java.util.Comparator;
import java.util.stream.IntStream;
import static java.util.Comparator.comparingDouble;

public class Test {
    public static void main(String[] args) {
        int array[][] = {{10, 20, 30},{40, 50, 60}, {1,2,3} };
        Arrays.sort(array, comparingDouble(row -> IntStream.of(row).average().getAsDouble()));
        Arrays.stream(array).map(Arrays::toString).forEach(System.out::println);
    }
}

The output:

[1, 2, 3]
[10, 20, 30]
[40, 50, 60]

For the reverse order use instead:

Arrays.sort(array, comparing(row -> IntStream.of(row).average().getAsDouble(), reverseOrder()));

The output:

[40, 50, 60]
[10, 20, 30]
[1, 2, 3]

EDIT: WITH NO STREAMS

Without using streams what you can do is the following:

1 - Get the array with the averages of the matrix rows:

float[] arrayAverage = average(matrix);

You already know how to calculate the average, therefore you just need to extract a method out of the code that you have created, namely:

private static float[]average(int[][] array) {
    float[] arrayAverage = new float[array.length];
    float sum = 0;
    for (int i = 0; i < array.length; i++) {
        for (int j = 0; j < array[i].length; j++) {
            sum += array[i][j];
        }
        arrayAverage[i] = (float) (Math.round((sum / array[i].length) * 100.0) / 100.0);
        sum = 0;
    }
    return arrayAverage;
}

2 - Create an array that will represent the rows and initialized as the following:

int [] row_position = new int [arrayAverage.length];
for(int i = 0; i < row_position.length; i++)
    row_position[i] = i;

3 - Sort the arrayAverage using the easiest sort, the bubble sort. While sorting that array update accordingly the positions stored on the row_position:

for(int i=0; i < arrayAverage.length; i++){
    for(int j=1; j < (arrayAverage.length-i); j++){
        if(arrayAverage[j-1] > arrayAverage[j]){
            float temp = arrayAverage[j-1];
            arrayAverage[j-1] = arrayAverage[j];
            arrayAverage[j] = temp;
            int temp_pos = row_position[j-1];
            row_position[j-1] = row_position[j];
            row_position[j] = temp_pos;
        }
    }
}

4 - Now that you have the row_positions array that tells you how the sorted rows should be rearranged, you just need to swap the rows accordingly:

    int[][] tmp_matrix = new int [matrix.lenght][];
    for (int i = 0; i < tmp_matrix.length; i++) {
        tmp_matrix[i] = matrix[row_position[i]];
    }
    matrix = new_matrix;

Bear in mind, however, that for simplicity-sake I have assumed a quadratic matrix of NxN, and the above solution can be improved performance-wise.

At last, made it to work, looks like this.

import java.util.Arrays;
import java.util.Random;
import java.util.Scanner;

public class SortArray2D {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("Sorting two dimensional arrays!!!");
        System.out.print("Enter arrays 1st dimension size 10 - 20: ");
        int array1stDsize = sc.nextInt();
        System.out.println();
        sc.close();

        if (array1stDsize > 20 || array1stDsize < 10) {
            System.out.println("The number you enteraed is too big or too small!!!");
        } else {

            int[][] array = new int[array1stDsize][];
            Random random = new Random();
            for (int i = 0; i < array.length; i++) {
                array[i] = new int[random.nextInt(31) + 10];
                for (int j = 0; j < array[i].length; j++) {
                    int input = new Random().nextInt(900) + 100;
                    array[i][j] = input;
                }
            }
            System.out.println("Array element output: ");
            arrayOutput(array);
            // array element sorting from biggest to smallest
            for (int k = 0; k < array.length; k++) {
                for (int i = 1; i < array[k].length; i++) {
                    for (int j = i; j > 0; j--) {
                        if (array[k][j] > array[k][j - 1]) {
                            int element = array[k][j];
                            array[k][j] = array[k][j - 1];
                            array[k][j - 1] = element;

                        }
                    }
                }
            }
            System.out.println();
            System.out.println("Descending Array element output: ");
            arrayOutput(array);

            System.out.println();
            System.out.println("Average value output by array: ");
            float[] arrayAverage = new float[array1stDsize];

            for (int i = 0; i < array.length; i = i + 1) {
                float sum = 0;
                for (int j = 0; j < array[i].length; j = j + 1) {
                    sum = sum + array[i][j];
                }
                float average = (float) (Math.round((sum / array[i].length) * 100.0) / 100.0);
                System.out.println(i + ". array average value: " + average);
                arrayAverage[i] = average;
            }
            // array lines sorting from by average value increasing
            for (int i = 0; i < arrayAverage.length; i = i + 1) {
                for (int j = i; j > 0; j--) {
                    if (arrayAverage[j] < arrayAverage[j - 1]) {
                        float tmpor = arrayAverage[j];
                        arrayAverage[j] = arrayAverage[j - 1];
                        arrayAverage[j - 1] = tmpor;

                        int[] tmp = array[j];
                        array[j] = array[j - 1];
                        array[j - 1] = tmp;
                    }
                }
            }
            System.out.println();
            System.out.print("Array from average values sorted: ");
            System.out.println(Arrays.toString(arrayAverage));
            System.out.println();
            System.out.println("Incerasing Array line output: ");
            arrayOutput(array);
            System.out.println();
            System.out.print("Most valuest array is array: ");
            double max = 100;
            int row = 0;
            for (int i = 0; i < arrayAverage.length; i++) {

                if (max < arrayAverage[i]) {
                    max = arrayAverage[i];
                    row = i;

                }
            }
            for (int j = 0; j < array[row].length; j = j + 1) {
                System.out.print(" " + array[row][j]);
            }
        }
    }

    public static int[][] arrayOutput(int[][] array) {
        for (int i = 0; i < array.length; i = i + 1) {
            for (int j = 0; j < array[i].length; j = j + 1) {
                if (j == 0) {
                    System.out.print("{ " + array[i][j]);
                } else {

                    System.out.print(", " + array[i][j]);
                }
            }
            System.out.print(" }");
            System.out.println();

        }
        return array;
    }
}

Output sorted 2d array in ascending order:

int[][] arr = {
        {12, 54, 87},  // avg 51
        {98, 56, 32},  // avg 62
        {19, 73, 46}}; // avg 46

Arrays.stream(arr)
        // sort an array by the
        // average value of the row
        .sorted(Comparator.comparingDouble(row ->
                // get the average value or 0 if the row is empty {}
                Arrays.stream(row).average().orElse(0)))
        // string representation
        // of the row content
        .map(Arrays::toString)
        // output line by line
        .forEach(System.out::println);

Output:

[19, 73, 46]
[12, 54, 87]
[98, 56, 32]