de.javagl.common.collections

Class Lists

java.lang.Object

de.javagl.common.collections.Lists

public class Lists
extends Object

Methods related to lists.

These methods are not part of the main API, and may be removed or moved to a different package or library in the future.

Method Summary

Modifier and Type	Method and Description
static <T> List<T>	concat(List<? extends T> list0, List<? extends T> list1) Create a new list that is an unmodifiable view on the concatenation of the given lists.
static <T> List<T>	createIndexView(List<T> parent, IntUnaryOperator indexLookup, int size) Create a view on the given list where each index will be passed through the given lookup function in order to access the corresponding element in the given parent list.
static <T> List<T>	createIndexView(List<T> parent, List<Integer> indices) Create a view on the given list that contains only the elements that are indicated by the given indices.
static <T> List<T>	createView(int size, IntFunction<? extends T> function) Create a view on the given function, as a list with the given size.
static <T> List<T>	createView(int minIndexInclusive, int maxIndexExclusive, IntFunction<? extends T> f) Returns a view on the given function, as a list that contains the elements f(minIndexInclusive) to f(maxIndexExclusive-1)
static <A,B,C> List<C>	createView(List<? extends A> list0, List<? extends B> list1, BiFunction<? super A,? super B,? extends C> function) Creates a list that is a view on the result of applying the given function to the elements of the given lists.
static <T,U> List<U>	createView(List<? extends T> list, Function<? super T,? extends U> function) Create a view on the given list that converts the values with the given function.
static <A,B,C,D> List<D>	createView(List<A> list0, List<B> list1, List<C> list2, TriFunction<? super A,? super B,? super C,? extends D> function) Creates a list that is a view on the result of applying the given function to the elements of the given lists.
static List<Integer>	fromArray(int... array) Returns a list that is an unmodifiable view on the given array
static List<Integer>	fromRange(int min, int max) Creates an unmodifiable list that contains consecutive integers in the given range
static List<Long>	fromRange(long min, long max) Creates an unmodifiable list that contains consecutive long values in the given range
static <T> List<T>	pad(List<? extends T> t, int padLeft, T padLeftValue, int padRight, T padRightValue) Returns a new list that is a view on the given list, padded with the specified number of elements.
static List<Double>	steps(double offset, double stepSize, int size) Returns an unmodifiable list with the given size that contains the values offset + i * stepSize
static List<Integer>	steps(int offset, int stepSize, int size) Returns an unmodifiable list with the given size that contains the values offset + i * stepSize
static List<Long>	steps(long offset, long stepSize, int size) Returns an unmodifiable list with the given size that contains the values offset + i * stepSize
static <T> List<T>	unmodifiableListWith(Collection<? extends T> input) Utility method that returns an unmodifiable list with the given contents
static void	validateIndex(int index, int size) Make sure that the given index is valid for a list with the given size, and throw an IndexOutOfBoundsException if this is not the case.
static void	validateSize(int size) Make sure that the given size is not negative, and throw an IllegalArgumentException otherwise
static <T> List<T>	withRandomAccess(List<T> list) Returns a new list that wraps the given one, adding the RandomAccess tagging interface.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

unmodifiableListWith

public static <T> List<T> unmodifiableListWith(Collection<? extends T> input)

Utility method that returns an unmodifiable list with the given contents

Type Parameters:

T - The type of the elements

Parameters:

input - The input

Returns:

The result

fromArray

public static List<Integer> fromArray(int... array)

Returns a list that is an unmodifiable view on the given array

Parameters:

array - The array

Returns:

The list

createView

public static <T,U> List<U> createView(List<? extends T> list,
                                       Function<? super T,? extends U> function)

Create a view on the given list that converts the values with the given function.

The resulting list will implement the RandomAccess interface if the given list implements it.

Type Parameters:

T - The input type

U - The result type

Parameters:

list - The list

function - The function

Returns:

The view

createView

public static <A,B,C> List<C> createView(List<? extends A> list0,
                                         List<? extends B> list1,
                                         BiFunction<? super A,? super B,? extends C> function)

Creates a list that is a view on the result of applying the given function to the elements of the given lists.

The resulting list will implement the RandomAccess interface if the given lists implement it.

Type Parameters:

A - The first element type

B - The second element type

C - The result type

Parameters:

list0 - The first list

list1 - The second list

function - The function to combine the elements

Returns:

The resulting list

Throws:

IllegalArgumentException - If the given lists have different sizes

createView

public static <A,B,C,D> List<D> createView(List<A> list0,
                                           List<B> list1,
                                           List<C> list2,
                                           TriFunction<? super A,? super B,? super C,? extends D> function)

Creates a list that is a view on the result of applying the given function to the elements of the given lists.

The resulting list will implement the RandomAccess interface if the given lists implement it.

Type Parameters:

A - The first element type

B - The second element type

C - The third element type

D - The result type

Parameters:

list0 - The first list

list1 - The second list

list2 - The third list

function - The function to combine the elements

Returns:

The resulting list

Throws:

IllegalArgumentException - If the given lists have different sizes

createView

public static <T> List<T> createView(int size,
                                     IntFunction<? extends T> function)

Create a view on the given function, as a list with the given size.

Type Parameters:

T - The element type

Parameters:

size - The size

function - The function

Returns:

The view

createView

public static <T> List<T> createView(int minIndexInclusive,
                                     int maxIndexExclusive,
                                     IntFunction<? extends T> f)

Returns a view on the given function, as a list that contains the elements f(minIndexInclusive) to f(maxIndexExclusive-1)

Type Parameters:

T - The element type

Parameters:

minIndexInclusive - The minimum index, inclusive

maxIndexExclusive - The maximum index, exclusive

f - The function

Returns:

The list

Throws:

IllegalArgumentException - If the given minimum index is larger than the maximum index

withRandomAccess

public static <T> List<T> withRandomAccess(List<T> list)

Returns a new list that wraps the given one, adding the RandomAccess tagging interface.

Type Parameters:

T - The element type

Parameters:

list - The list

Returns:

The resulting list

steps

public static List<Integer> steps(int offset,
                                  int stepSize,
                                  int size)

Returns an unmodifiable list with the given size that contains the values offset + i * stepSize

Parameters:

offset - The offset

stepSize - The step size

size - The size

Returns:

The list

Throws:

IllegalArgumentException - If the size is negative

steps

public static List<Long> steps(long offset,
                               long stepSize,
                               int size)

Returns an unmodifiable list with the given size that contains the values offset + i * stepSize

Parameters:

offset - The offset

stepSize - The step size

size - The size

Returns:

The list

Throws:

IllegalArgumentException - If the size is negative

steps

public static List<Double> steps(double offset,
                                 double stepSize,
                                 int size)

Returns an unmodifiable list with the given size that contains the values offset + i * stepSize

Parameters:

offset - The offset

stepSize - The step size

size - The size

Returns:

The list

Throws:

IllegalArgumentException - If the size is negative

fromRange

public static List<Integer> fromRange(int min,
                                      int max)

Creates an unmodifiable list that contains consecutive integers in the given range

Parameters:

min - The minimum value, inclusive

max - The maximum value, exclusive

Returns:

The list

Throws:

IllegalArgumentException - If the minimum is larger than the maximum

fromRange

public static List<Long> fromRange(long min,
                                   long max)

Creates an unmodifiable list that contains consecutive long values in the given range

Parameters:

min - The minimum value, inclusive

max - The maximum value, exclusive

Returns:

The list

Throws:

IllegalArgumentException - If the minimum is larger than the maximum

pad

public static <T> List<T> pad(List<? extends T> t,
                              int padLeft,
                              T padLeftValue,
                              int padRight,
                              T padRightValue)

Returns a new list that is a view on the given list, padded with the specified number of elements.

The resulting list will implement the RandomAccess interface if the given list implements it.

Type Parameters:

T - The element type

Parameters:

t - The input list

padLeft - The number of padding elements at the left

padLeftValue - The value for the left padding elements

padRight - The number of padding elements at the right

padRightValue - The value for the right padding elements

Returns:

The padded list

Throws:

IllegalArgumentException - If either of the given arguments is negative

createIndexView

public static <T> List<T> createIndexView(List<T> parent,
                                          List<Integer> indices)

Create a view on the given list that contains only the elements that are indicated by the given indices.

The returned list will me modifiable if and only if the given parent is modifiable. The given list may not be modified after it has been passed to this method.

Type Parameters:

T - The element type of the list

Parameters:

parent - The parent list

indices - The indices

Returns:

The view

Throws:

NullPointerException - If any argument is null

createIndexView

public static <T> List<T> createIndexView(List<T> parent,
                                          IntUnaryOperator indexLookup,
                                          int size)

Create a view on the given list where each index will be passed through the given lookup function in order to access the corresponding element in the given parent list. The caller is responsible for making sure that the lookup works properly (i.e. it does not throw an exception for any argument).

The returned list will me modifiable if and only if the given parent is modifiable.

Type Parameters:

T - The element type of the list

Parameters:

parent - The parent list

indexLookup - The lookup

size - The size of the resulting list

Returns:

The view

Throws:

NullPointerException - If any argument is null

concat

public static <T> List<T> concat(List<? extends T> list0,
                                 List<? extends T> list1)

Create a new list that is an unmodifiable view on the concatenation of the given lists.

Type Parameters:

T - The type of the elements

Parameters:

list0 - The first list

list1 - The second list

Returns:

The concatenated view

validateSize

public static void validateSize(int size)

Make sure that the given size is not negative, and throw an IllegalArgumentException otherwise

Parameters:

size - The size

Throws:

IllegalArgumentException - If the size is negative

validateIndex

public static void validateIndex(int index,
                                 int size)

Make sure that the given index is valid for a list with the given size, and throw an IndexOutOfBoundsException if this is not the case.

Parameters:

index - The index

size - The size

Throws:

IndexOutOfBoundsException - If the index is negative or not smaller than the size