Create a 4x4 arrangement in java

This is how a multidimensional array is declared:

int matriz[][] = new int[4][4];

You can declare and initialize it at the same time as follows:

int matriz[][] = {{3,8,7,6}, {7,5,7,4}, {3,2,1,0}, {9,6,4,8}}

You must post how you calculate what you need and the code of how you tried to do it.

I understand that you want to get the average of each of the sub-arrays and then make the average of all of these. To create multidimensional arrays (arrays), you must write:

int matriz[][] = new int [4][4]
//tambien crearemos unas variables para guardar las medias
int mediaTotal = 0;
int subMedia = 0;

To be able to move through them you must create a double for (nested for):

for(i=0;i<matriz.lenght;i++){
   for(j=0;j<matriz.lenght;i++){
//aqui harias la media de cada sub-array
submedia += matriz[i][j];
}
System.out.println("media de sub-array "+i+": "+subMedia)
mediaTotal += submedia/2;
} 
System.out.println("media total de todos los arrays: "+mediaTotal);

As for the deviations ... I do not know what you mean, I hope I helped you. An upvote is appreciated: P

To solve this problem you can use the streams of java 8 and a collector to calculate the standard deviation

 int data[][] = { { 3, 8, 7, 6 }, { 7, 5, 7, 4 }, { 3, 2, 1, 0 }, { 9, 6, 4, 8 } };
    Arrays.stream(data).mapToDouble(x ->  Arrays.stream(x).
            average().
            orElse(0) ).
            forEach(s -> System.out.println("promedio "+s));

    double average = Arrays.stream(data).
            flatMapToInt(Arrays::stream).
            average().orElse(0);
    System.out.println("promedio total "+average);

    Arrays.stream(data).mapToDouble(x ->  Arrays.stream(x).
            mapToDouble((int s) -> 1.0 * s).
            boxed().
            collect(DoubleStatistics.collector())).
            forEach(s -> System.out.println("desviacion estandar "+s));

    double r = Arrays.stream(data).
                    flatMapToInt(Arrays::stream).
                    mapToDouble((int s) -> 1.0 * s).
                    boxed().
                    collect(DoubleStatistics.collector());

    System.out.println("desviacion estandar total "+r);

and the collector code

public class DoubleStatistics extends DoubleSummaryStatistics {

    private double sumOfSquare = 0.0d;
    private double sumOfSquareCompensation; // Low order bits of sum
    private double simpleSumOfSquare; // Used to compute right sum for
    // non-finite inputs

    @Override
    public void accept(double value) {
        super.accept(value);
        double squareValue = value * value;
        simpleSumOfSquare += squareValue;
        sumOfSquareWithCompensation(squareValue);
    }

    public DoubleStatistics combine(DoubleStatistics other) {
        super.combine(other);
        simpleSumOfSquare += other.simpleSumOfSquare;
        sumOfSquareWithCompensation(other.sumOfSquare);
        sumOfSquareWithCompensation(other.sumOfSquareCompensation);
        return this;
    }

    private void sumOfSquareWithCompensation(double value) {
        double tmp = value - sumOfSquareCompensation;
        double velvel = sumOfSquare + tmp; // Little wolf of rounding error
        sumOfSquareCompensation = (velvel - sumOfSquare) - tmp;
        sumOfSquare = velvel;
    }

    public double getSumOfSquare() {
        double tmp = sumOfSquare + sumOfSquareCompensation;
        if (Double.isNaN(tmp) && Double.isInfinite(simpleSumOfSquare)) {
            return simpleSumOfSquare;
        }
        return tmp;
    }

    public final double getStandardDeviation() {
        long count = getCount();
        double sumOfSquare = getSumOfSquare();
        double average = getAverage();
        return count > 0 ? Math.sqrt((sumOfSquare - count * Math.pow(average, 2)) / (count - 1)) : 0.0d;
    }

    public static Collector<Double, DoubleStatistics, Double> collector() {
    return Collector.of(DoubleStatistics::new,
            DoubleStatistics::accept, DoubleStatistics::combine, DoubleStatistics::getStandardDeviation);
}

}