I'm trying to get combinations but I don't know how to do it

In a test case, I have 1 2 3 4 as the inputs, I want to get

{1+2, 3+4}

{1+3, 2+4}

{1+4, 2+3}

but I only can do {1+2, 3+4} I can't think of any ways to get {1+3, 2+4}.
I need some algorithm advice, can't think of any conditions to do this.

for (int j=0; j<woodLength.length; j++) {
        if (woodLength[j][2] != 1) {
            // a function that can create the boards using the wood pieces
            for (int i=0; i<woodLength.length; i++) {
                // set used boards as 1 and unused as 0
                if (woodLength[i][1] != 1) {
                    woodenBoardHeight.add(woodLength[i][0]+woodLength[i+1][0]);
                    System.out.println(woodenBoardHeight.get(wBHCount));
                    wBHCount ++;
                    woodLength[i][1] = 1;
                    woodLength[i+1][1] = 1;
                }
            }
            for (int i=0; i<woodLength.length; i++) {
                woodLength[i][1] = 0;
            }
            woodLength[j][2] = 1;
            woodLength[j+1][2] = 1;
        }
    }

this is my code, right now this prints {3,7} but I also want {4,6} and {5,5}

If it's helpful, I'm trying to solve CCC 2017 Senior S3 question

https://www.cemc.uwaterloo.ca/contests/computing/2017/stage%201/seniorEF.pdf

One algorithm to create all the combinations of an array makes use of an unsigned binary counter.

Array:  1  2  3  4

        0  0  0  0     [] empty combination
        0  0  0  1     [4]
        0  0  1  0     [3]
        0  0  1  1     [3, 4]

and so on.

In your case, you want the combinations that are 2 digits plus 2 digits. We can achieve this by testing the binary counter and creating the combination when the binary counter has exactly 2 bits on.

Array:  1  2  3  4

        0  0  1  1     [3, 4] & [1, 2]
        0  1  0  1     [2, 4] & [1, 3]
        0  1  1  0     [2, 3] & [1, 4]
        1  0  0  1     [1, 4] & [2, 3]
        1  0  1  0     [1, 3] & [2, 4]
        1  1  0  0     [1, 2] & [3, 4]

In your example, the order of the pairs is not important. You can eliminate the duplicate pairs, and you have the three conditions you're looking for.

Use this code to get the solution as expected

 public static void main(String[] args) {
    List<Integer> num;
    Integer[] numArray = {1,2,3,4};
    num = Arrays.asList (numArray);
    List<Integer> newList = new ArrayList<> ();

    for(int i=1;i<num.size ();i++) {
        int[] intArray = new int[2];
        newList.addAll (num);
        newList.remove (0);
        newList.remove (i-1);
        intArray[0]=num.get (0)+num.get (i);
        intArray[1] = newList.get (0)+newList.get (1);
        System.out.println ("{"+intArray[0]+","+intArray[1]+"}");

    }
}

The Result will be like this :

{3,7}
{4,6}
{5,5}