Матрица

import java.util.Arrays;
import java.util.Random;
 
public class Task019 {
    public static void main(String[] args) {
        int n = 10;
        int m = 15;
        int[][] matrix = createAndRandomFillMatrix(n, m, -9, 9);
        System.out.println("Дана матрица:\n" + toStringMatrix(matrix));
 
        int[][] positiveMatrix = getPositiveNumbersToLineMatrix(matrix);
        System.out.println("Положительная матрица:\n" + toStringMatrix(positiveMatrix));
 
        int[] sumArray = sumElements(positiveMatrix);
        System.out.println("Суммы значений строк положительной матрицы:\n" + Arrays.toString(sumArray));
    }
 
    public static int[][] createAndRandomFillMatrix(int n, int m, int min, int max) {
        int[][] matrix = n > 0 && m > 0 ? new int[n][m] : new int[0][0];
        if (n > 0 && m > 0) {
            Random rand = new Random();
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < m; j++) {
                    matrix[i][j] = rand.nextInt(Math.abs(max - min) + 1) + min;
                }
            }
        }
        return matrix;
    }
 
    public static int[] sumElements(int[][] matrix) {
        int sum[] = new int[matrix.length];
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[i].length; j++) {
                sum[i] += matrix[i][j];
            }
        }
        return sum;
    }
 
    public static int[][] getPositiveNumbersToLineMatrix(int[][] matrix) {
        int[][] result = matrix != null ? new int[matrix.length][0] : new int[0][0];
        if (matrix != null) {
            for (int i = 0; i < matrix.length; i++) {
                result[i] = Arrays.copyOf(result[i], matrix[i].length);
                int count = 0;
                for (int j = 0; j < matrix[i].length; j++) {
                    if (matrix[i][j] > 0) {
                        if (matrix[i][j] > 0) {
                            result[i][count++] = matrix[i][j];
                        }
                    }
                }
                result[i] = Arrays.copyOf(result[i], count);
            }
        }
        return result;
    }
 
    public static String toStringMatrix(int[][] matrix) {
        StringBuilder sb = new StringBuilder();
        if (matrix != null) {
            for (int[] line : matrix) {
                sb.append(Arrays.toString(line)).append(System.lineSeparator());
            }
        }
        return sb.toString();
    }
}

public class Main {
    private static int [][] arrForWork;
 
    private static int getRndValue(int lowLim ,int hightLim){
        long lengRet;
        do {
            lengRet = Math.round(Math.random()*hightLim);
        }while (lengRet < lowLim);
        return (int)lengRet;
    }
 
    private static int [] getColumn(int[][] arrTarget, int numCol) {
        int [] forRet = new int[arrTarget.length];
        for (int i = 0; i < arrTarget.length; i++) {
            forRet[i] = arrTarget[i][numCol];
        }
        return forRet;
    }
 
    private static int getSumPositivElements(int[] arrTarget) {
        int sum = 0;
        for (int val : arrTarget)
            if (val > 0)
                sum += val;
        return sum;
    }
 
    private static void fillArrOnlyPositivRndValue(int[][] arrTarget, int minVal, int maxVal) {
        for (int i = 0; i < arrTarget.length; i++) {
            for (int j = 0; j < arrTarget[0].length; j++) {
                arrTarget[i][j] = getRndValue(minVal,maxVal);
            }
        }
    }
 
    private static void addInArrNegativRndValue(int[][] arrTarget) {
        int rowRnd, colRnd;
        for (int k = 0; k < arrTarget.length * arrTarget[0].length / 2; k++) {
            rowRnd = (int)Math.round(Math.random()*(arrTarget.length - 1));
            colRnd = (int)Math.round(Math.random()*(arrTarget[0].length - 1));
            arrTarget[rowRnd][colRnd] = -1*arrTarget[rowRnd][colRnd];
        }
    }
 
    private static void printValueArr(int[][] arrTarget, boolean flagPositiv){
        if (flagPositiv){
            for (int [] row : arrTarget) {
                for (int val : row)
                    if (val > 0)
                        System.out.printf("%4d",val);
                    else System.out.printf("%4s","*");
                System.out.println();
            }
        }
        else {
            for (int [] row : arrTarget) {
                for (int val : row)
                    System.out.printf("%4d",val);
                System.out.println();
            }
        }
    }
 
    public static void main(String[] args) {
        int row = 3;
        int col = 4;
        arrForWork = new int[row][col];
        int minLimVal = 0, maxLimVal = 9;
        fillArrOnlyPositivRndValue(arrForWork, minLimVal, maxLimVal);
        addInArrNegativRndValue(arrForWork);
        System.out.println("Исходный массив:");
        printValueArr(arrForWork,false);
        System.out.println("Положительные элементы массива:");
        printValueArr(arrForWork,true);
        System.out.println("Сумма положителных элементов:");
        for (int c = 0; c < col; c++) {
            System.out.printf("%d-го столбца = %d\n", c, getSumPositivElements(getColumn(arrForWork,c)));
        }
    }
}