Java: split a List into two sub-Lists?

Question

What's the simplest, most standard, and/or most efficient way to split a List into two sub-Lists in Java? It's OK to mutate the original List, so no copying should be necessary. The method signature could be

/** Split a list into two sublists. The original list will be modified to
 * have size i and will contain exactly the same elements at indices 0 
 * through i-1 as it had originally; the returned list will have size 
 * len-i (where len is the size of the original list before the call) 
 * and will have the same elements at indices 0 through len-(i+1) as 
 * the original list had at indices i through len-1.
 */
<T> List<T> split(List<T> list, int i);

[EDIT] List.subList returns a view on the original list, which becomes invalid if the original is modified. So split can't use subList unless it also dispenses with the original reference (or, as in Marc Novakowski's answer, uses subList but immediately copies the result).

Answer 1

Getting the returned array is pretty easy using the subList method, but there's no easy way that I know of to remove a range of items from a List.

Here's what I have:

<T> List<T> split(List<T> list, int i) {
 List<T> x = new ArrayList<T>(list.subList(i, list.size()));
 // Remove items from end of original list
 while (list.size() > i) {
  list.remove(list.size() - 1);
 }
 return x;
}

Answer 2

Riffing on Marc's solution, this solution uses a for loop that saves some calls to list.size():

<T> List<T> split(List<T> list, int i) {
    List<T> x = new ArrayList<T>(list.subList(i, list.size()));
    // Remove items from end of original list
    for (int j=list.size()-1; j>i; --j)
        list.remove(j);
    return x;
}

Answer 3

<T> List<T> split(List<T> list, int i) {
    List<T> upper = new ArrayList<T>();
    while (list.size() > i) {
        upper.add(list.remove(i));
    }
    return upper;
}

Answer 4

Quick semi-pseudo code:

List sub=one.subList(...);
List two=new XxxList(sub);
sub.clear(); // since sub is backed by one, this removes all sub-list items from one

That uses standard List implementation methods and avoids all the running around in loops. The clear() method is also going to use the internal removeRange() for most lists and be a heckuva lot more efficient.

Answer 5

Likewise cribbing off of Marc's list, we'll use List.removeAll() to remove the duplicate entries from the second list. Note that, strictly speaking, this only follows the specs if the original list contained no duplicate items: otherwise, the original list may be missing items.

<T> List<T> split(List<T> list, int i) {
        List<T> x = new ArrayList<T>(list.subList(i, list.size()));
        // Remove items from end of original list
        list.removeAll(x);
        return x;
}

Answer 6

<T> List<T> split(List<T> list, int i) {
   List<T> secondPart = list.sublist(i, list.size());
   List<T> returnValue = new ArrayList<T>(secondPart());
   secondPart.clear(),
   return returnValue;
}

Answer 7

A generic function to split a list to a list of list of specific size. I was missing this for long in java collections.

private List<List<T>> splitList(List<T> list, int maxListSize) {
        List<List<T>> splittedList = new ArrayList<List<T>>();
        int itemsRemaining = list.size();
        int start = 0;

        while (itemsRemaining != 0) {
            int end = itemsRemaining >= maxListSize ? (start + maxListSize) : itemsRemaining;

            splittedList.add(list.subList(start, end));

            int sizeOfFinalList = end - start;
            itemsRemaining = itemsRemaining - sizeOfFinalList;
            start = start + sizeOfFinalList;
        }

        return splittedList;
    }

Answer 8

In the last posting from Coder by Force, there is an error, the first line of the while block must be like this:

int end = itemsRemaining >= maxListSize ? (start + maxListSize) : (start + itemsRemaining);