Java Composite List

Question

I'm looking for a opensource library that has an implementation of a composite list. I need a list that reads its values from some other lists and can be constructed something like this:

List list1 = new ArrayList();
list1.add("0");
List list2 = new LinkedList();
list2.add("1");
list3.add("2");
List list3 = new CompositeList(list1, list2...)

then:

assertEquals("0", list3.get(0));
assertEquals("1", list3.get(1));
assertEquals("2", list3.get(2));

The idea is that I don't need to copy over everything from the source lists.

A quick google didn't find anything, I didn't see it in Guava or commons collections (I may have overlooked it). I don't really have the time to implement it properly right now.

Answer 1

I was looking inside Guava for something similar this morning, and finally stumbled upon Iterables.concat().

You asked specifically for a List view, so this might not exactly solve your problem, but this is one option to keep in mind.

I also thought I needed a Collection / List at first, but I later realized it wasn't mandatory to solve my problem: I was mainly looking for something to concat multiple iterables (obtained by various Guava filtering/transformations), before filtering/transforming the result, to finally dump it into an ImmutableList. Returning the Iterable view is also an option, if you only need to iterate on the result.

PS (a few years later): those transformations / concatenations can now be done using Guava's FluentIterable or Java 8 streams too.

Answer 2

CompositeCollection from Commons Collections seems to do what you need, even if it's not generified.

Answer 3

You can use org.apache.commons.collections15.collection.CompositeCollection, and it's generic.

See http://search.maven.org/#artifactdetails%7Cnet.sourceforge.collections%7Ccollections-generic%7C4.01%7Cjar

Answer 4

We can build one. I use Guava for iterator() implementation but it wouldn't be hard to roll your own.

/**
 * A list composed of zero to many child lists.  Additions occur in the first
 * acceptable list: if an insertion is attempted at an index that lies on a break
 * between lists, the insert occurs in the first list. Modifications are undefined
 * if list of lists has no elements.
 * @param <T> Type of element stored in list.
 */
public class CompositeList<T> extends AbstractList<T> {
// member variables ---------------------------------------------------------------
    private Collection<List<T>> mLists;

// constructors -------------------------------------------------------------------
    public CompositeList(Collection<List<T>> pLists) {mLists = pLists;}

// methods ------------------------------------------------------------------------
    /** Sum of sizes of component lists. */
    public int size() {return mLists.stream().mapToInt(Collection::size).sum();}

    @Override public T get(int pIdx) {
        final Map.Entry<List<T>,Integer> m = findIndex(pIdx);
        return m.getKey().get(m.getValue());
    }

    /**
     * If add could occur at end of one list or beginning of the next, the former
     * behavior is guaranteed.
     */
    @Override public void add(int pIdx, T pElement) {
        if (pIdx == 0) {
            mLists.iterator().next().add(0, pElement);
        } else {
            // find prior object
            final Map.Entry<List<T>,Integer> m = findIndex(pIdx - 1);
            m.getKey().add(m.getValue() + 1, pElement);
        }
    }

    @Override public T remove(int pIdx) {
        final Map.Entry<List<T>,Integer> m = findIndex(pIdx);

        // don't auto-box because remove(Object) and remove(int) can be confused
        return m.getKey().remove(m.getValue().intValue());
    }

    @Override public T set(int pIdx, T pElement) {
        final Map.Entry<List<T>,Integer> m = findIndex(pIdx);
        return m.getKey().set(m.getValue(), pElement);
    }

    /** More efficient than superclass implementation. */
    @Override public Iterator<T> iterator() {
        return Iterators.concat(
            Collections2.transform(mLists, Collection::iterator).iterator()
        );
    }

    @Override public void clear() {mLists.forEach(Collection::clear);}

    /**
     * Identify list and index that composite index refers to. For
     * [A], [], [], [B, C]; composite index 1 would return the fourth list
     * mapped to the number 0.
     */
    private Map.Entry<List<T>,Integer> findIndex(int pCompositeIdx) {
        // composite index of list's starting point
        int listStart = 0;
        for (final List<T> list : mLists) {
            if (listStart + list.size() > pCompositeIdx) {
                return new AbstractMap.SimpleImmutableEntry<>(
                    list, pCompositeIdx - listStart
                );
            }
            listStart += list.size();
        }
        throw new IndexOutOfBoundsException(pCompositeIdx + " >= " + size());
    }
}

Answer 5

Check javakarta collections, CompositeCollection:

http://commons.apache.org/collections/apidocs/index.html