Большие и маленькие символы в массиве

    static Queue<Character> lower = new ArrayDeque<>();
    static Queue<Character> upper = new ArrayDeque<>();
 
    public static void main(String[] args) {
 
        char[] arr = new char[]{'a', 'b', 'C', 'D', 'E', 'f', 'g'};
        fillLists(arr);
        char[] arr2 = fillArr(lower, upper);
        System.out.println(arr2);
 
    }
 
    private static char[] fillArr(Queue<Character> lower, Queue<Character> upper) {
 
        boolean lastLower = false;
        int len = lower.size() + upper.size();
        List<Character> arrList = new ArrayList<>();
 
        while (!lower.isEmpty() || !upper.isEmpty()) {
            if (!lower.isEmpty() && !upper.isEmpty()) {
                if (lastLower) {
                    arrList.add(upper.poll());
                    lastLower = false;
                } else {
                    arrList.add(lower.poll());
                    lastLower = true;
                }
            } else {
                if (lower.isEmpty()) {
                    arrList.addAll(upper);
                    upper.clear();
                } else {
                    arrList.addAll(lower);
                    lower.clear();
                }
            }
        }
        char[] arr = new char[arrList.size()];
        for (int i = 0; i < arrList.size(); i++) {
            arr[i] = arrList.get(i);
        }
        return arr;
    }
 
    private static void fillLists(char[] arr) {
        for (char c : arr) {
            if (Character.isLowerCase(c)) {
                lower.add(c);
            } else {
                upper.add(c);
            }
        }
    }

package com.we2seek.cyberforum.chararray;
 
import org.junit.Assert;
import org.junit.Test;
 
import java.util.Arrays;
 
public class App {
        private static final char[] source = "aBCcbAD".toCharArray();
 
    public static void main(String[] args) {
        System.out.println(source);
        System.out.println(alterCase(source));
    }
 
    public static final char[] alterCase(final char[] original) {
        // 1. Sort
        Arrays.sort(original);
 
        // 2. Find border between Upper and lowercase. The uppercase sequence comes first
        int lowerCaseStartsFrom = 0;
        while (lowerCaseStartsFrom++ < original.length && Character.isUpperCase(original[lowerCaseStartsFrom])) {
        }
 
        char[] upper = Arrays.copyOfRange(original, 0, lowerCaseStartsFrom);
        char[] lower = Arrays.copyOfRange(original, lowerCaseStartsFrom, original.length);
 
        // 3. Find common elements (same size)
        int maxCommon = upper.length > lower.length ? lower.length : upper.length;
 
        char[] result = new char[original.length];
        int i = 0;
        while (i <= maxCommon - 1) {
            result[i * 2] = upper[i];
            result[i * 2 + 1] = lower[i];
            i++;
        }
 
        // 4. Copy rest to the end
        if (upper.length > lower.length) {
            System.arraycopy(upper, maxCommon, result, maxCommon * 2, upper.length - maxCommon);
        } else if (lower.length > upper.length) {
            System.arraycopy(lower, maxCommon, result, maxCommon * 2, lower.length - maxCommon);
        }
 
        return result;
    }
 
    @Test
    public void testAlterCase1() {
        char[] src = {'d', 'f', 'g', 'F', 'D', 'G'};
        char[] alteredChars = alterCase(src);
        Assert.assertNotNull(alteredChars);
        Assert.assertEquals(src.length, alteredChars.length);
 
        Assert.assertArrayEquals("DdFfGg".toCharArray(), alteredChars);
    }
 
    @Test
    public void testAlterCase2() {
        char[] src = {'d', 'f', 'F', 'D', 'G'};
        char[] alteredChars = alterCase(src);
        Assert.assertNotNull(alteredChars);
        Assert.assertEquals(src.length, alteredChars.length);
 
        Assert.assertArrayEquals("DdFfG".toCharArray(), alteredChars);
    }
 
    @Test
    public void testAlterCase3() {
        char[] src = {'d', 'f', 'g', 'F', 'D'};
        char[] alteredChars = alterCase(src);
        Assert.assertNotNull(alteredChars);
        Assert.assertEquals(src.length, alteredChars.length);
 
        Assert.assertArrayEquals("DdFfg".toCharArray(), alteredChars);
    }
}

public class LettersArray {
 
    public static void main(String[] args) {
 
        char[] arr = new char[]{'a', 'b', 'C', 'D', 'E', 'f', 'g', 'z', 'x'};
        printArray(arr);
        //
        int lp = 0; // позиция в массиве строчных букв
        int up = 0; // тоже, но для заглавных
        int capQty = getCapitalLettersQty(arr);
        char[] lArr = new char[arr.length - capQty];
        char[] uArr = new char[capQty];
        // раскидываем заглавные и строчные в разные массивы
        for (char c : arr) {
            if (Character.isUpperCase(c)) uArr[up++] = c;
            else lArr[lp++] = c;
        }
        // берем из массивов по одной букве и пишем в исходный массив
        lp = 0;
        up = 0;
        for (int i = 0; i < arr.length - 1; i += 2) {
            if (lp < lArr.length) arr[i] = lArr[lp++];
            if (up < uArr.length) arr[i + 1] = uArr[up++];
        }
        printArray(arr);
    }
 
    private static int getCapitalLettersQty(char[] arr) {
        int q = 0;
        for (char c : arr) {
            if (Character.isUpperCase(c)) q++;
        }
        return q;
    }
 
    private static void printArray(char[] arr) {
        for (char c : arr) {
            System.out.print(c);
        }
        System.out.println();
    }
}

        char[] arr = new char[]{'a', 'b', 'C', 'D', 'E', 'f', 'g', 'z', 'x'};
        int[] place = {0, -1};
        int[][] a = new int[arr.length][];
        Arrays.setAll(a, i -> new int[]{arr[i], Character.isLowerCase(arr[i]) ? (place[1] += 2) : (place[0] += 2)});
        Arrays.sort(a, (i, j) -> i[1] - j[1]);
        for (int i = 0; i < arr.length; i++) arr[i] = (char) a[i][0];
        System.out.println(Arrays.toString(arr));

        String s = "cbaCBA";
        Map<Boolean, List<Character>> partitioned = s.chars().mapToObj(c -> (char) c).collect(partitioningBy(Character::isUpperCase));
        List<Character> lows = partitioned.get(false);
        List<Character> caps = partitioned.get(true);
        int minSize = Math.min(lows.size(), caps.size());
        List<Character> head = IntStream.range(0, minSize).boxed().flatMap(i -> Stream.of(lows.get(i), caps.get(i))).collect(toList());
        List<Character> tail = (minSize == lows.size() ? caps : lows).stream().skip(minSize).collect(toList());
        head.addAll(tail);
        System.out.println(head);