Определить, есть ли в матрице столбец, в котором равное количество положительных и отрицательных элементов

import javax.swing.JOptionPane;
 
public class ARR {
    
    public static void main(String[] args) 
    {
        int[][] array={
            {3, 1, 3, -2},
            {2, 9, -1, 8},
            {1, -3, 3, 4},
            {8, 1, -1, -8},};    
        int positive = 0, negative = 0, box = 0;    
            for (int i=0; i < array.length; i++)
                
            { 
                for (int j = 0; j < array.length; j++)
            {
                    if (array[i][j]>0)
                        positive++;
                        else negative++;
            }
            if (positive == negative)
                box = i+1;
            
            } JOptionPane.showMessageDialog(null, "№ "+ box);
    }
}

import java.util.Arrays;
import java.util.Random;
 
public class A {
    //задаём размер массива 4 на 4
    public static final int DEFAULT_SIZE = 4;
 
    //интервал чисел для заполнения массива от -2 до 2
    public static int minRange = -2;
    public static int maxRange = 2;
 
    public static void main(String[] args) {
        int[][] array = new int[DEFAULT_SIZE][DEFAULT_SIZE];
        Random random = new Random();
 
        //заполняем массив рандомными числами и выводим на экран
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                array[i][j] = random.nextInt(maxRange - minRange + 1) + minRange;
            }
            System.out.println(Arrays.toString(array[i]));
        }
 
 
 
        int index = -1;
        for (int i = 0; i < array.length; i++) {
            int count = 0;
            for (int j = 0; j < array[i].length; j++) {
                if (array[i][j] >= 0) {
                    count++;
                } else {
                    count--;
                }
            }
 
            if (count == 0) {
                index = i;
                break;
            }
        }
 
        if (index != -1) {
            System.out.printf("В рядку %d рівна кількість додатніх та від'ємних елементів\n", index + 1);
        } else {
            System.out.printf("немає такого рядка, щоб була рівна кількість додатніх та від'ємних елементів\n", 0);
        }
    }
}

if (array[i][j] >= 0) {
                    count++;
                } else {
                    count--;
                }

if (array[i][j] > 0) {
                    count++;
                } else if (array[i][j] < 0) {
                    count--;
                }

import java.util.Arrays;
import java.util.Random;
 
public class A {
    public static final int DEFAULT_SIZE = 4;
    public static int minRange = -2;
    public static int maxRange = 2;
 
    public static void main(String[] args) {
        int[][] array = new int[DEFAULT_SIZE][DEFAULT_SIZE];
        Random random = new Random();
 
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                array[i][j] = random.nextInt(maxRange - minRange + 1) + minRange;
            }
            System.out.println(Arrays.toString(array[i]));
        }
        
        int index = -1;
        for (int i = 0; i < array.length; i++) {
            int positive = 0;
            int negative = 0;
            for (int j = 0; j < array[i].length; j++) {
                if (array[i][j] > 0) {
                    positive++;
                } else if (array[i][j] < 0) {
                    negative++;
                }
            }
            if (positive == negative && positive != 0) {
                index = i;
                break;
            }
        }
 
        if (index != -1) {
            System.out.printf("В рядку %d рівна кількість додатніх та від'ємних елементів\n", index + 1);
        } else {
            System.out.printf("немає такого рядка, щоб була рівна кількість додатніх та від'ємних елементів\n", 0);
        }
    }
}

import java.util.Arrays;
import java.util.Random;
 
public class A {
    //кол-во строк в массиве.
    private static final int HEIGHT = 4;
 
    //кол-во столбцов в массиве.
    private static final int WEIGHT = 4;
 
    //диапазон чисел для рандомной генерации.
    private static int minRange = -2;
    private static int maxRange = 2;
 
    /**
     * Метод создаёт двумерный массив, заполненый рандомными числами в диапазоне.
     *
     * @param height - высота массива; (кол-во строк);
     * @param weight - ширина массива (кол-во столбцов);
     * @param minRange - минимальное число для рандома;
     * @param maxRange - максимальное число для рандома;
     * @return возвращает двумерный массив;
     */
    private static int[][] createDeepArray(int height, int weight, int minRange, int maxRange) {
        int[][] deepArray = height > 0 && weight > 0 ? new int[height][weight] : new int[0][0];
        Random random = new Random();
        for (int i = 0; i < deepArray.length; i++) {
            for (int j = 0; j < deepArray[i].length; j++) {
                deepArray[i][j] = random.nextInt(maxRange - minRange + 1) + minRange;
            }
        }
        return deepArray;
    }
 
    /**
     * Метод печатает двумерный массив в консоль.
     *
     * @param deepArray - массив для печати;
     */
    private static void printDeepArray(int[][] deepArray) {
        if (deepArray != null) {
            for (int[] line : deepArray) {
                System.out.println(Arrays.toString(line));
            }
        }
    }
 
    /**
     * Метод ищет строки в двумерном массиве, в которых отриц. и полож. чисел одинаково.
     *
     * @param deepArray - массив для поиска;
     * @return массив индексов строк двумерного массива;
     */
    private static int[] getLineArray(int[][] deepArray) {
        int[] result = deepArray != null ? new int[deepArray.length] : new int[0];
        int amount = 0;
        for (int i = 0; i < deepArray.length; i++) {
            int positive = 0;
            int negative = 0;
            for (int j = 0; j < deepArray[i].length; j++) {
                if (deepArray[i][j] > 0) {
                    positive++;
                } else if (deepArray[i][j] < 0) {
                    negative++;
                }
            }
            if (positive == negative && positive != 0) {
                result[amount++] = i;
            }
        }
        result = Arrays.copyOf(result, amount);
        return result;
    }
 
    /**
     * Метод печатает результат в консоль.
     *
     * @param result - массив индексов;
     */
    private static void printResult(int[] result) {
        if (result != null) {
            if (result.length > 0) {
                for (int index : result) {
                    System.out.printf("В рядку %d рівна кількість додатніх та від'ємних елементів;\n", index + 1);
                }
            } else {
                System.out.println("Hемає такого рядка, щоб була рівна кількість додатніх та від'ємних елементів;");
            }
        }
    }
 
    public static void main(String[] args) {
        int[][] deepArray = createDeepArray(HEIGHT, WEIGHT, minRange, maxRange);
        printDeepArray(deepArray);
        int[] result = getLineArray(deepArray);
        printResult(result);
    }
}

import java.util.Arrays;
import java.util.Random;
 
public class A {
    public static final int HEIGHT = 4;
    public static final int WEIGHT = 4;
    public static int minRange = -2;
    public static int maxRange = 2;
 
    public static void main(String[] args) {
        int[][] array = new int[HEIGHT][WEIGHT];
        Random random = new Random();
 
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                array[i][j] = random.nextInt(maxRange - minRange + 1) + minRange;
            }
            System.out.println(Arrays.toString(array[i]));
        }
 
        boolean isAnswer = false;
        for (int i = 0; i < array.length; i++) {
            int positive = 0;
            int negative = 0;
            for (int j = 0; j < array[i].length; j++) {
                if (array[i][j] > 0) {
                    positive++;
                } else if (array[i][j] < 0) {
                    negative++;
                }
            }
            if (positive == negative && positive != 0) {
                System.out.printf("В рядку %d рівна кількість додатніх та від'ємних елементів\n", i + 1);
                isAnswer = true;
            }
        }
 
        if (!isAnswer) {
            System.out.println("немає такого рядка, щоб була рівна кількість додатніх та від'ємних елементів");
        }
    }
}