Combining two Arraylists into one Array

Question

Suppose you have two arrayLists: A and B.

How do I create a new array which is the same size as B and stores the index values of A as integers in sequential order.

So say for example the size of B is 5 and A has 3 values.

A[0] = Ra
A[1] = Be
A[2] = Ce


B[0] = F
B[1] = M
B[2] = K
B[3] = P
B[4] = L

I want to then create in java different possible versions (say 5 versions) of an arrayC of size 5 (the same size as listB) with a sequential ordering of the indexes of listA.

So like:

arrayC[0] = 0
arrayC[1] = 1
arrayC[2] = 1
arrayC[3] = 2
arrayC[4] = 2

or

arrayC[0] = 0
arrayC[1] = 0
arrayC[2] = 1
arrayC[3] = 2
arrayC[4] = 2

are both valid combinations in arrayC. However

arrayC[0] = 0
arrayC[1] = 2
arrayC[2] = 1
arrayC[3] = 2
arrayC[4] = 2

is not.

the question is very confusing - you need to clarify in a more exact way (perhaps more examples?) what is it that you want to achieve. I can't make heads or tails from the question! — Chii
– Chii, Commented Jun 22, 2011 at 10:45
Sorry, I thought the examples made it clear. I'll try again, it's quite difficult to explain it. — Pandy
– Pandy, Commented Jun 22, 2011 at 10:47
So if listA is smaller, you want to randomly duplicate some values? Is that right? What if listA is larger than listB? And does the actual content of listB have any significance? Or only its size? — Joachim Sauer
– Joachim Sauer, Commented Jun 22, 2011 at 10:49
the sentence "in sequential order, but different combinations." is kind of self-contradictory — dm76
– dm76, Commented Jun 22, 2011 at 10:49

Steve · Accepted Answer · 2011-06-22 11:40:05Z

1

    ArrayList a = new ArrayList();
    a.add(new Object());
    a.add(new Object());
    a.add(new Object());

    ArrayList b = new ArrayList();
    b.add(new Object());
    b.add(new Object());
    b.add(new Object());
    b.add(new Object());
    b.add(new Object());

    Random r = new Random();
    int c[] = new int[b.size()];
    int aIndex = 0;
    for(int i = 0; i <c.length; i++){

        if(i != 0) { //assume we always use aIndex = 0 for first element

            if((c.length - i) < a.size() - aIndex ){ //must increase the index
                aIndex++;
            }
            else if(r.nextBoolean() && aIndex < a.size()-1){ //Randomly increase the index
                aIndex++;
            }
        }
        c[i] = aIndex;
        System.out.print("\nC[" +i +"]:" + aIndex);
    }

edited Jun 22, 2011 at 11:40

answered Jun 22, 2011 at 11:18

Steve

3632 silver badges11 bronze badges

Sign up to request clarification or add additional context in comments.

3 Comments

Steve Over a year ago

...edited to add in the array list setup. The question specifies ArrayLists into an Array

Steve Over a year ago

you don't need to add anything, just wrap the above code in a Main() or unit test and run it. It will generate a new random valid output each time. cheers Steve

Steve Over a year ago

SAMPLE OUTPUT: C[0]:0 C[1]:0 C[2]:1 C[3]:2 C[4]:2

G_H · Accepted Answer · 2011-06-22 11:51:53Z

Alright, assuming I'm understanding the question correctly, here's a program that will print every combination of 5 numbers ranging from 0 to 2. The getAllCombinations method is general-purpose, so you can simply alter the values to see different results.

A word of warning: this uses recursion and calculates all results, so it's not very efficient. This is just to get you on your way.

package test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Main {

    public static void main(final String[] args) {

        final int sizeA = 3;
        final int sizeB = 5;

        final List<int[]> combos = getAllCombinations(sizeA-1, sizeB);

        int counter = 1;
        for(final int[] combo : combos) {
            System.out.println("Combination " + counter);
            System.out.println("--------------");
            for(final int value : combo) {
                System.out.print(value + " ");
            }
            System.out.println();
            System.out.println();
            ++counter;
        }

    }

    private static List<int[]> getAllCombinations(final int maxIndex, final int size) {

        if(maxIndex >= size)
            throw new IllegalArgumentException("The maximum index must be smaller than the array size.");

        final List<int[]> result = new ArrayList<int[]>();

        if(maxIndex == 0) {
            final int[] array = new int[size];
            Arrays.fill(array, maxIndex);
            result.add(array);
            return result;
        }

        //We'll create one array for every time the maxIndex can occur while allowing
        //every other index to appear, then create every variation on that array
        //by having every possible head generated recursively
        for(int i = 1; i < size - maxIndex + 1; ++i) {

            //Generating every possible head for the array
            final List<int[]> heads = getAllCombinations(maxIndex - 1, size - i);

            //Combining every head with the tail
            for(final int[] head : heads) {
                final int[] array = new int[size];
                System.arraycopy(head, 0, array, 0, head.length);
                //Filling the tail of the array with i maxIndex values
                for(int j = 1; j <= i; ++j)
                    array[size - j] = maxIndex;
                result.add(array);
            }

        }

        return result;

    }

}

@Pandy One thing you could do is to get the List with getAllCombinations, then select a bunch of arrays from it at random. Still computes every possible combination, though.

aioobe · Accepted Answer · 2011-06-22 11:55:50Z

This method returns all orderings. Limit it if you just want a few.

public static Set<List<Integer>> orderings(int i, int len, int max) {

    Set<List<Integer>> seqs = new HashSet<List<Integer>>();

    if (len <= 0 || i > max)
        return seqs;

    if (max - i == len) {
        List<Integer> l = new ArrayList<Integer>();
        while (i < max)
            l.add(i++);
        seqs.add(l);
        return seqs;
    }

    seqs.addAll(orderings(i    , len - 1, max));
    seqs.addAll(orderings(i + 1, len - 1, max));

    for (List<Integer> l : seqs)
        l.add(0, i);

    return seqs;
}


public static Set<List<Integer>> orderings(int[] arr1, int[] arr2) {
    return orderings(0, arr2.length, arr1.length);
}

Test code:

public static void main(String[] args) {
    int[] listA = { 0, 1, 2 };
    int[] listB = { 0, 1, 2, 3, 4 };
    for (List<Integer> seq : orderings(listA, listB))
        System.out.println(seq);
}

Output:

[0, 0, 1, 2, 2]  <-- your second example
[0, 1, 1, 1, 2]
[0, 1, 1, 2, 2]  <-- your first example
[0, 1, 2, 2, 2]
[0, 0, 0, 1, 2]
[0, 0, 1, 1, 2]

Ideone.com demo:
Link

Collectives™ on Stack Overflow

Combining two Arraylists into one Array

3 Answers 3

3 Comments

2 Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

3 Comments

2 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related