Java ListIterator Usage overlap(List> lists, int before, int after)

Description

Introduces overlap into a series of lists.

License

Open Source License

Parameter

Parameter	Description
before	# of elements from the end of the previous list to prepend
after	# of elements from the beginning of the next list to append

Declaration

public static <T> List<List<T>> overlap(List<List<T>> lists, int before, int after) 

Method Source Code

//package com.java2s;
/**/* w  ww.j  av a2 s  . com*/
  * Copyright 2014 Google Inc. All rights reserved.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  * 
  *     http://www.apache.org/licenses/LICENSE-2.0
  * 
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
*/

import java.util.ArrayList;

import java.util.List;
import java.util.ListIterator;

public class Main {
    /**
      * Introduces overlap into a series of lists. 
      * @param before # of elements from the end of the previous list to prepend
      * @param after # of elements from the beginning of the next list to append
    */
    public static <T> List<List<T>> overlap(List<List<T>> lists, int before, int after) {

        if (before < 0) {
            throw new IllegalArgumentException("Value of before cannot be negative");
        }
        if (after < 0) {
            throw new IllegalArgumentException("Value of after cannot be negative");
        }

        ListIterator<List<T>> iter = lists.listIterator();

        List<List<T>> result = new ArrayList<List<T>>();
        for (; iter.hasNext();) {
            List<T> current = new ArrayList<T>(iter.next());
            List<T> prev = before > 0 ? findPrevious(iter) : null;
            List<T> next = after > 0 ? findNext(iter) : null;
            if (prev != null) {
                List<T> overlap = prev.subList(prev.size() - before, prev.size());
                current.addAll(0, overlap);
            }
            if (next != null) {
                List<T> overlap = next.subList(0, after);
                current.addAll(overlap);
            }
            result.add(current);
        }

        return result;
    }

    private static <T> T findPrevious(ListIterator<T> iter) {
        T prev = null;
        iter.previous(); // rewind
        if (iter.hasPrevious()) {
            prev = iter.previous();
            iter.next(); // come back
        }
        iter.next(); // come back
        return prev;
    }

    private static <T> T findNext(ListIterator<T> iter) {
        T next = null;
        if (iter.hasNext()) {
            next = iter.next();
            iter.previous(); // come back
        }
        return next;
    }
}

Related

1. listHasIdentContent(List list_1, List list_2)
2. listToStringArray(java.util.List list)
3. makeSortFieldFallbackExpr(List fieldNames)
4. normalizeVersion(String version, int length)
5. numberToDigits(int num)
6. parsePath(String sPath)
7. partialSort(List list, int numTop, Comparator c)
8. peekNext(ListIterator it)
9. peekNext(ListIterator iterator)