Создать массив из 12 случайных чисел таким образом, чтобы отрицательных и положительных было поровну

public class New {
 
    public static void main(String[] args){
 
        Random random = new Random();
        int rand, quantPlus = 0, quantMinus = 0;
        ArrayList<Integer> arr = new ArrayList<>();
 
        do {
            //генерируем очередное число, если равно 0 генерируем заново
            do {
                rand = random.nextInt(21) - 10;
            } while (rand == 0);
 
            //добавляем в массив
            arr.add(rand);
 
            //считаем отрицательное или положительное
            if (rand > 0)
                quantPlus++;
            else quantMinus++;
 
            //все это делаем пока отрицательных или положительных не станет 6 штук
        } while (quantMinus != 6 && quantPlus != 6);
 
        //если отрицательных 6 штук, то остаток заполняем положительными
        if (quantMinus == 6){
            do {
                arr.add(random.nextInt(10) + 1);
            } while (arr.size() < 12);
        }
        //если отрицательных НЕ 6 штук, то значит положительных 6 штук и остаток заполняем отрицательными
        else {
            do {
                arr.add(random.nextInt(10) - 10);
            } while (arr.size() < 12);
        }
 
    }
}

public class New {
 
    public static void main(String[] args){
 
        //нижняя и верхняя границы и размер массива
        int lowerLimit = -5, upperLimit = 7, sizeArr = 10;
        
        Random random = new Random();
        ArrayList<Integer> arr = new ArrayList<>();
        int rand, quantPlus = 0, quantMinus = 0;
        int interval = Math.abs(lowerLimit) + upperLimit;
 
        do {
            //генерируем очередное число, если равно 0 генерируем заново
            do {
                rand = random.nextInt(interval + 1) + lowerLimit;
            } while (rand == 0);
 
            //добавляем в массив
            arr.add(rand);
 
            //считаем отрицательное или положительное
            if (rand > 0) quantPlus++;
            else quantMinus++;
 
            //все это делаем пока отрицательных или положительных не станет половина
        } while (quantMinus != sizeArr/2 && quantPlus != sizeArr/2);
 
        //если отрицательных половина, то остаток заполняем положительными
        if (quantMinus == sizeArr/2){
            do {
                arr.add(random.nextInt(upperLimit) + 1);
            } while (arr.size() < sizeArr);
        }
        //если отрицательных НЕ половина, то значит положительных половина и остаток заполняем отрицательными
        else {
            do {
                arr.add(random.nextInt(Math.abs(lowerLimit)) + lowerLimit);
            } while (arr.size() < sizeArr);
        }
 
        quantMinus = quantPlus = 0;
        for (int i = 0; i < arr.size(); i++){
            if (arr.get(i) > 0) quantPlus++;
            else quantMinus++;
        }
 
        System.out.println(arr + " " + quantPlus + " " + quantMinus);
 
    }
}

import java.util.Arrays;
import java.util.Random;
 
public class Massiv {
 
    final static Random r = new Random();
 
    public static void main(String[] args) {
        int[] arr = makeArray(12);
        System.out.println(Arrays.toString(arr));
    }
 
    static int[] makeArray(int size) {
        int half = size / 2;
        int[] arr = new int[size];
        for (int i = 0; i < size; i++) {
            arr[i] = r.nextInt(10) + 1;
            if (i < half) arr[i] *= -1;
        }
        shuffleArray(arr);
        return arr;
    }
 
    static void shuffleArray(int[] arr) {
        for (int i = arr.length - 1; i > 0; i--) {
            int pos = r.nextInt(i + 1);
            int d = arr[pos];
            arr[pos] = arr[i];
            arr[i] = d;
        }
    }
}

import java.util.Arrays;
import java.util.Random;
 
public class Programm {
    private static final int[] numbersInRangeArray = {1,2,3,4,5,6,7,8,9,10};
    
    public static void main(String[] args) {
        int[] array = generateRandomArray(12);
        System.out.println(Arrays.toString(array));
    }
    private static int[] generateRandomArray(int size) {
        Random rnd = new Random();
        int[] resultArray = new int[size];
        for(int i=0; i<size; i++) {
            resultArray[i] = getRandomElement(numbersInRangeArray, rnd.nextInt() % 2 == 0 ? 1 : -1);
        }
        return resultArray;
    }
    private static int getRandomElement(int[] targetArray, int multipleFactor) {
        return multipleFactor * targetArray[(int)(Math.random() * (targetArray.length-1))];
    }
}

import java.util.Arrays;
import java.util.Random;
 
public class Programm {
 
    private static final int DELETED_CELL = -666;
 
    public static void main(String[] args) {
        int[] array = generateRandomArray(12);
        System.out.println(Arrays.toString(array));
    }
 
    private static int[] generateRandomArray(int size) {
        Random rnd = new Random();
        int[] positives = generateInRage(1, 10, size/2);
        int[] negatives = generateInRage(-10, -1, size/2);
        int[] resultArray = new int[size];
        int[] currentRepository = null;
        int currentIndex = 0;
 
        do{
            currentRepository = rnd.nextInt() % 2 == 0 ? positives : negatives;
            if(canPull(currentRepository)) {
                resultArray[currentIndex++] = pullFromRepository(currentRepository);
            }
        }while(!isComplete(resultArray));
        
        return resultArray;
    }
 
    private static boolean isComplete(int[] targetArray) {
        for (int number : targetArray) {
            if(number == 0) {
                return false;
            }
        }
        return true;
    }
 
    private static boolean canPull(int[] repoArray) {
        for(int i=0; i<repoArray.length; i++) {
            if(repoArray[i] != DELETED_CELL) {
                return true;
            }
        }
        return false;
    }
 
    private static int pullFromRepository(int[] repoArray) {
        int resultNumber = 0;
        for(int i=0; i < repoArray.length; i++) {
            if(repoArray[i] != DELETED_CELL) {
                resultNumber = repoArray[i];
                repoArray[i] = DELETED_CELL;
                return resultNumber;
            }
        }
        throw new RuntimeException("Should not get here");
    }
 
    private static int[] generateInRage(int min, int max, int size) {
        int[] resultArray = new int[size];
        for (int i = 0; i < size ; i++) {
            resultArray[i] = (int) (Math.random() * (max - min) + min);
        }
        return resultArray;
    }
}

public class Massiv {
 
    private final static Random r = new Random();
    private final static int SIZE = 12;
 
    public static void main(String[] args) {
        int[] arr = makeArray(SIZE);
        System.out.println(Arrays.toString(arr));
    }
 
    static int[] makeArray(int size) {
        int[] arr = new int[size];
        for (int i = 0; i < size; i++) {
            arr[i] = r.nextInt(10) + 1;
        }
        invertSomeValues(arr);
        return arr;
    }
 
    private static void invertSomeValues(int[] arr) {
        int half = SIZE / 2;
        while (half > 0) {
            int pos = r.nextInt(SIZE);
            if (arr[pos] > 0) {
                arr[pos] *= -1;
                half--;
            }
        }
    }
}

public class SixAndSix {
 
    public static void main(String[] args) {
        int[] finish = runner();
        System.out.println(Arrays.toString(finish));
    }
 
    public static int[] runner() {
        int a = 62;
        int[] uno = pusk(a);
        for (int i = 0; i < a; i++) {
            if (uno[i] == 0) {
                uno[i] = (int) -(Math.random() * 50 + 1);
            }
        }
        return uno;
    }
 
    public static int[] pusk(int n) {
        int count = n / 2;
        int[] duo = new int[n];
        while (count > 0) {
            int q = (int) (Math.random() * n);       //случайные позиции
            duo[q] = (int) (Math.random() * 50 + 1); //заполним всякой чешуёй
            count = n / 2;
            for (int i = 0; i < n; i++) { //посчитаем сколько ненулевых элементов
                if (duo[i] != 0) {
                    count--;
                }
            }
        }
        return duo;
    }
}

package less5;
 
public class Vk1 {
 
    static int rand1() {
        int c = (int) (Math.random() * 10 - 11);
        do {
            return c;
        } while (c != 0);
        // minus
        // return (int) (Math.random()*10-10);
    }
 
    static int rand2() {
        int l = (int) (Math.random() * (-10) + 11);
        do {
            return l;
        } while (l != 0);
    }
 
    // plus
 
    static double r3() {
        return Math.random();
    }
 
    static int[] rt(int s) {
        int a[] = new int[s];
        for (int i = 0; i < s/2; i++) {if(r3()<=.5&r3()>0){a[i] = rand1();}else{a[i] = rand2();}}
        for (int i = s/2; i < s; i++) {if(r3()>.5&r3()<=1){a[i] = rand2();}else{a[i] = rand1();}}
        return a;
    }
    public static void main(String[] args) {
        System.out.println();
 
        int f[] = rt(12);
        for (int i : f) {
            System.out.print(" " + i + "");
        }
    }
}
/*
 * . Программа должна создать массив из 12
 * случайных целых чисел из отрезка [-10;10] таким образом, чтобы отрицательных
 * и положительных элементов там было поровну и не было нулей. При этом порядок
 * следования элементов должен быть случаен (т. е. не подходит вариант, когда в
 * массиве постоянно выпадает сначала 6 положительных, а потом 6 отрицательных
 * чисел или же когда элементы постоянно чередуются через один и пр.). Вывести
 * полученный массив на экран.
 */