Алгоритм перебора

import java.util.*;
 
/**
 * Permutation generator
 * @param <E>
 */
class PermutationIterator<E extends List<? extends Comparable>> implements Iterator<E> {
    private E values;
    boolean firstIteration;
 
    public PermutationIterator(E values, boolean firstIteration) {
        this.values = values;
        this.firstIteration = firstIteration;
        Collections.sort(this.values);
    }
    public PermutationIterator(E values) {
        this(values, true);
    }
 
    @Override
    public boolean hasNext() {
        if (firstIteration) return true;
        int smallestIndex = values.size() - 2;
        while (smallestIndex >= 0 && values.get(smallestIndex).compareTo(values.get(smallestIndex + 1)) >= 0)
            --smallestIndex;
        return smallestIndex >= 0;
    }
 
    private <T> void swap(List<T> values, int i, int j) {
        T temp = values.get(i);
        values.set(i, values.get(j));
        values.set(j, temp);
    }
 
    @Override
    public E next() {
        if (firstIteration) {
            firstIteration = false;
            return values;
        }
        // find the largest index k such that a[k] < a[k + 1].
        int smallestIndex = values.size() - 2;
 
        while (smallestIndex >= 0 && values.get(smallestIndex).compareTo(values.get(smallestIndex + 1)) >= 0)
            --smallestIndex;
        // if no such index exists, the permutation is the last permutation
        if (smallestIndex < 0) return null;
        // find the largest index l such that a[k] < a[l].
        int largestIndex = values.size() - 1;
        while (largestIndex > smallestIndex && values.get(smallestIndex).compareTo(values.get(largestIndex)) >= 0) --largestIndex;
        // swap found
        swap(values, smallestIndex, largestIndex);
        // revert order of remaining elements
        for (int i = values.size() - 1, j = smallestIndex + 1; i > j; ++j, --i)
            swap(values, i, j);
        return values;
    }
 
    @Override
    public void remove() {
        throw new UnsupportedOperationException("there is no way to remove a permutation");
    }
}
 
/**
 * Generates permutations of a list using iterator.
 */
class Permutation<T extends Comparable<T>> implements Iterable<List<T>> {
    private List<T> values;
 
    public Permutation(List<T> values) {
        this.values = values;
        Collections.sort(this.values);
    }
 
    @Override
    public Iterator<List<T>> iterator() {
        return new PermutationIterator<List<T>>(new ArrayList<T>(values));
    }
}
 
 
public class Main {
    public static <T> void print(List<T> list) {
        for (T i : list) System.out.print(i + " ");
        System.out.println();
    }
 
    public static void main(String[] args) {
        for (List<String> list : new Permutation<String>(Arrays.asList("cat", "dog", "cow")))
            print(list);
        for (List<Integer> list : new Permutation<Integer>(Arrays.asList(1, 1, 2, 4)))
            print(list);
    }
}