I have my own version. Waiting desperately for Closures in Java :
public static <T, E> Iterable<T> transformMany(Iterable<E> iterable, Func<E, Iterable<T>> f) {
    if (null == iterable)
        throw new IllegalArgumentException("null iterable");
    if (null == f)
        throw new IllegalArgumentException("null f");
    return new TransformManyIterable<E, T>(iterable, f);
}
public interface Func<E, T> {
    T execute(E e);
}
public class TransformManyIterable<TOriginal, TResult> implements Iterable<TResult> {
    private Iterable<TOriginal> iterable;
    private Func<TOriginal, Iterable<TResult>> func;
    public TransformManyIterable(Iterable<TOriginal> iterable,
            Func<TOriginal, Iterable<TResult>> func) {
        super();
        this.iterable = iterable;
        this.func = func;
    }
    class TransformIterator implements Iterator<TResult> {
        private Iterator<TOriginal> iterator;
        private Iterator<TResult> currentIterator;
        public TransformIterator() {
            iterator = iterable.iterator();
        }
        @Override
        public boolean hasNext() {
            if (currentIterator != null && currentIterator.hasNext())
                return true;
            else {
                while (iterator.hasNext()) {
                    Iterable<TResult> iterable = func.execute(iterator.next());
                    if (iterable == null)
                        continue;
                    currentIterator = iterable.iterator();
                    if (currentIterator.hasNext())
                        return true;
                }
            }
            return false;
        }
        @Override
        public TResult next() {
            if (currentIterator != null && currentIterator.hasNext())
                return currentIterator.next();
            else {
                while (iterator.hasNext()) {
                    Iterable<TResult> iterable = func.execute(iterator.next());
                    if (iterable == null)
                        continue;
                    currentIterator = iterable.iterator();
                    if (currentIterator.hasNext())
                        return currentIterator.next();
                }
            }
            throw new NoSuchElementException();
        }
        @Override
        public void remove() {
            throw new UnsupportedOperationException();
        }
    }
    @Override
    public Iterator<TResult> iterator() {
        return new TransformIterator();
    }
}
Usage:
    Iterable<SomeType> result = transformMany(input, new Func<InputType, Iterable<SomeType>>() {
        @Override
        public Iterable<SomeType> execute(InputType e) {
            return new ArrayList<SomeType>();
        }
    });