Miksowanie tablicy z samą sobą

Dzień dobry,
Mam tablicę:

ArrayList<Integer> liczby = new ArrayList<Integer>();

Zawiera ona około 500 liczb.
Teraz muszę pomnożyć każdą liczbę z tej tablicy z każdą liczbą z tej tablicy.
Np.
tablica = {1, 2, 3}
w wyniku chcę otzrymać
wynik = { 11, 12, 13, 22, 23, 33 }
Lepiej żeby się nie powtarzały, ale jak muszą to trudno, poradzę sobie.
Jak to zrobić? Z góry za pomoc dziękuję ;)

Raz, ze to nie jest wcale tablica.
Dwa - wiesz co to petle? Jak sie moga powtarzac to np tak:

int[] orig = { 1, 2, 3 };
int[] multi = new int[orig.length * orig.length];
for (int i = 0; i < orig.length; ++i) {
    for (int j = 0; j < orig.length; ++j) {
        multi[i * orig.length + j] = orig[i] * orig[j];
    }
}
for (int i = 0; i < multi.length; ++i) {
    System.out.print(multi[i] + " ");
}

Tak się nie powtarza

public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<Integer>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        ArrayList<Integer> multipledNumbers = new ArrayList<Integer>();
        int[][] checker = new int[numbers.size() * numbers.size()][2];
        int checkerIndex = 0;
        boolean exists;
        for (Integer x : numbers) {
            for (Integer y : numbers) {
                exists = false;
                for (int i = 0; i < checker.length; i++) {
                    if ((checker[i][0] == x && checker[i][1] == y) ||
                            (checker[i][0] == y && checker[i][1] == x)) {
                        exists = true;
                        break;
                    }
                }
                if (!exists) {
                    checker[checkerIndex][0] = x;
                    checker[checkerIndex++][1] = y;
                    multipledNumbers.add(x * y);                    
                }
            }
        }

        for (Integer i : multipledNumbers) {
            System.out.println(i);
        }
    }

Można też skorzystać ze zbiorów.

        ArrayList<Integer> numbers = new ArrayList<Integer>();
        for(int i=0;i<20;i++)
            numbers.add(i);
        HashSet<Integer> multipledNumbers = new HashSet<Integer>();
        for (Integer x : numbers)
        {
            for (Integer y : numbers)
            {
                multipledNumbers.add(x*y);
            }
        }
        Integer[] result=new Integer[multipledNumbers.size()];
        result=multipledNumbers.toArray(result);
        for (int i=0;i<result.length;i++)
        {
            System.out.println(result[i]);
        }

też się nie powtarzają

x * y == y * x, więc można to zapisać dwa razy efektywniej:

for (int i = 0; i < numbers.length; i++){
     int x = numbers[i];
     for (int j = i; j < numbers.length; j++){ // od j = i
          multipledNumbers.add(x*numbers[j]);
    }
}

Wypisać można łatwiej tak:

System.out.println(Arrays.toString(result));

Zdecydowanie najszybsze bedzie chyba to:

public static void main(String[] args) {
        int[] arr = { 2, 4, 6, 8 };
        int[] mul = new int[size(arr.length)];
        int index = 0;
        int x;
        for (int i = 0; i < arr.length; ++i) {
            x = arr[i];
            for (int j = i; j < arr.length; ++j) {
                mul[index] = x * arr[j];
                ++index;
            }
        }
        for (int i = 0; i < mul.length; ++i) {
            System.out.print(mul[i] + " ");
        }
    }

    private static int size(int n) {
        int res = 1;
        while (n > 1) {
            res += n;
            --n;
        }
        return res;
    }

Lub wrecz to:

int[] arr = { 2, 4, 6, 8 };
int[] mul = new int[(1 + arr.length) * arr.length / 2]; // Sn = (1 + n) * n /2)
int index = 0;
int x;
for (int i = 0; i < arr.length; ++i) {
    x = arr[i];
    for (int j = i; j < arr.length; ++j) {
        mul[index] = x * arr[j];
        ++index;
    }
}
for (int i = 0; i < mul.length; ++i) {
    System.out.print(mul[i] + " ");
}

@ucilala

Niestety rozwiązanie nie jest poprawne, bo np. 41 = 22, czyli w tablicy będą duplikaty.

Alternatywnie można utworzyć tablicę z duplikatami, posortować ją i następnie usunąć duplikaty prostym algorytmem O(wielkość tablicy).

Tak, ale ta sa duplikaty wynikow, a nie czynnikow mnozenia. Ja tak zrozumialem to zagadnienie - nie powinny sie powtarzac czynniki. Np duplikatem dla mnie jest 1x4 i 4x1, ale 1x4 i 2x2 juz nie. Takie jakby permutacje bez powtorzen plus mozliwosc mnozenia liczby przez sama siebie.
Mozliwe ze faktycznie zle zrozumialem.
Dobranoc.