All Implemented Interfaces:

kotlin.Cloneable , kotlin.collections.Collection , kotlin.collections.Iterable , kotlin.collections.List , kotlin.collections.MutableCollection , kotlin.collections.MutableIterable , kotlin.collections.MutableList
```
public final class LinkedList<T extends Object>
 implements List<T>, Cloneable
                    
```
Implementation of the MutableList interface for PolyUI.
This is a doubly-linked list, with special "fast" methods:
these methods are all designed to avoid the allocation of an Iterator object, as otherwise PolyUI would create a lot of garbage.
this collection, unlike most of the collections in the Java Collections Framework, does not make any effort to check against concurrent modification.
Being a linked list, the random get and put operations are not the best. However, this operation is rare in PolyUI, so it's okay to use this.
Since:

1.0.0

Nested Class Summary

Nested Classes
Modifier and Type	Class	Description
`public final class`	`LinkedList.Node`

Field Summary

Fields
Modifier and Type	Field	Description
`private final LinkedList.Node<T>`	`start`
`private final LinkedList.Node<T>`	`end`
`private final Integer`	`size`

Constructor Summary

Constructors
Constructor	Description
`LinkedList(Collection<T> elements)`
`LinkedList(T elements)`
`LinkedList()`

Enum Constant Summary

Enum Constants
Enum Constant	Description

Method Summary

Modifier and Type	Method	Description
`final LinkedList.Node<T>`	`getStart()`
`final LinkedList.Node<T>`	`getEnd()`
`Integer`	`getSize()`
`Boolean`	`addAll(Integer index, Collection<T> elements)`
`Boolean`	`addAll(Collection<T> elements)`
`Unit`	`clear()`
`final Unit`	`clear(Boolean unlink)`
`Unit`	`add(Integer index, T element)`
`Boolean`	`add(T element)`
`Boolean`	`isEmpty()`
`ListIterator<T>`	`iterator()`
`ListIterator<T>`	`listIterator()`
`ListIterator<T>`	`listIterator(Integer index)`
`T`	`removeAt(Integer index)`
`List<T>`	`subList(Integer fromIndex, Integer toIndex)`
`Integer`	`lastIndexOf(T element)`
`Boolean`	`retainAll(Collection<T> elements)`
`Boolean`	`removeAll(Collection<T> elements)`
`Boolean`	`remove(T element)`
`Boolean`	`containsAll(Collection<T> elements)`
`T`	`get(Integer index)`
`Integer`	`indexOf(T element)`
`T`	`set(Integer index, T element)`
`Boolean`	`contains(T element)`
`final Unit`	`fastEach(Function1<T, Unit> action)`
`final Unit`	`fastEachIndexed(Function2<Integer, T, Unit> action)`
`final Unit`	`fastEachReversed(Function1<T, Unit> action)`
`final Boolean`	`fastRemoveIf(Function1<T, Boolean> predicate)`
`final Boolean`	`fastRemoveIfIndexed(Function2<Integer, T, Boolean> predicate)`
`final Boolean`	`fastRemoveIfReversed(Function1<T, Boolean> predicate)`
`final Boolean`	`clearing(Function1<T, Unit> function)`
`final T`	`addOrReplace(T element)`
`final Unit`	`cut(Integer from, Integer to)`	Sublist this list in the range of from to to, discarding any elements outside of that range.
`final Unit`	`_remove(LinkedList.Node<T> node)`	Remove a node from a LinkedList.
`final Boolean`	`allAre(Function1<T, Boolean> predicate)`	Returns `true` if all elements match the given predicate.
`final T`	`first()`
`final T`	`first(Function1<T, Boolean> predicate)`
`final T`	`last()`
`Boolean`	`equals(Object other)`
`Integer`	`hashCode()`
`final LinkedList<T>`	`copy()`
`LinkedList<T>`	`clone()`
`String`	`toString()`

Methods inherited from class kotlin.collections.Iterable
forEach
Methods inherited from class kotlin.collections.Collection
parallelStream, stream, toArray
Methods inherited from class kotlin.collections.MutableCollection
removeIf
Methods inherited from class kotlin.collections.MutableList
replaceAll, sort
Methods inherited from class kotlin.collections.List
spliterator
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

LinkedList
```
LinkedList(Collection<T> elements)
```

LinkedList
```
LinkedList(T elements)
```

LinkedList
```
LinkedList()
```

Method Detail

getStart
```
 final LinkedList.Node<T> getStart()
```

getEnd
```
 final LinkedList.Node<T> getEnd()
```

getSize
```
 Integer getSize()
```

addAll

 Boolean addAll(Integer index, Collection<T> elements)

addAll

 Boolean addAll(Collection<T> elements)

clear
```
 Unit clear()
```

clear
```
 final Unit clear(Boolean unlink)
```

add
```
 Unit add(Integer index, T element)
```

add
```
 Boolean add(T element)
```

isEmpty
```
 Boolean isEmpty()
```

iterator
```
 ListIterator<T> iterator()
```

listIterator
```
 ListIterator<T> listIterator()
```

listIterator

 ListIterator<T> listIterator(Integer index)

removeAt
```
 T removeAt(Integer index)
```

subList

 List<T> subList(Integer fromIndex, Integer toIndex)

lastIndexOf
```
 Integer lastIndexOf(T element)
```

retainAll

 Boolean retainAll(Collection<T> elements)

removeAll

 Boolean removeAll(Collection<T> elements)

remove
```
 Boolean remove(T element)
```

containsAll

 Boolean containsAll(Collection<T> elements)

get
```
 T get(Integer index)
```

indexOf
```
 Integer indexOf(T element)
```

set
```
 T set(Integer index, T element)
```

contains
```
 Boolean contains(T element)
```

fastEach

 final Unit fastEach(Function1<T, Unit> action)

fastEachIndexed

 final Unit fastEachIndexed(Function2<Integer, T, Unit> action)

fastEachReversed

 final Unit fastEachReversed(Function1<T, Unit> action)

fastRemoveIf

 final Boolean fastRemoveIf(Function1<T, Boolean> predicate)

fastRemoveIfIndexed

 final Boolean fastRemoveIfIndexed(Function2<Integer, T, Boolean> predicate)

fastRemoveIfReversed

 final Boolean fastRemoveIfReversed(Function1<T, Boolean> predicate)

clearing

 final Boolean clearing(Function1<T, Unit> function)

addOrReplace
```
 final T addOrReplace(T element)
```

cut
```
 final Unit cut(Integer from, Integer to)
```
Sublist this list in the range of from to to, discarding any elements outside of that range.
This function is effectively equal to subList, but it effects this list, rather than returning a new one.

Parameters:

from - the start index, must be more than 0 and less than to

to - the end index, must be less than size and more than from

_remove
```
 final Unit _remove(LinkedList.Node<T> node)
```
Remove a node from a LinkedList. Note that if the node does not belong in this list, the behaviour is undefined.

allAre
```
 final Boolean allAre(Function1<T, Boolean> predicate)
```
Returns true if all elements match the given predicate.
Note this function will return true if the list is empty, according to the principle of Vacuous truth, and the fact that there are no elements that don't match the given predicate.

first
```
 final T first()
```

first

 final T first(Function1<T, Boolean> predicate)

last
```
 final T last()
```

equals
```
 Boolean equals(Object other)
```

hashCode
```
 Integer hashCode()
```

copy
```
 final LinkedList<T> copy()
```

clone
```
 LinkedList<T> clone()
```

toString
```
 String toString()
```

Class LinkedList

Nested Class Summary

Field Summary

Constructor Summary

Enum Constant Summary

Method Summary

Methods inherited from class kotlin.collections.Iterable

Methods inherited from class kotlin.collections.Collection

Methods inherited from class kotlin.collections.MutableCollection

Methods inherited from class kotlin.collections.MutableList

Methods inherited from class kotlin.collections.List

Methods inherited from class java.lang.Object

Constructor Detail

LinkedList

LinkedList

LinkedList

Method Detail

getStart

getEnd

getSize

addAll

addAll

clear

clear

add

add

isEmpty

iterator

listIterator

listIterator

removeAt

subList

lastIndexOf

retainAll

removeAll

remove

containsAll

get

indexOf

set

contains

fastEach

fastEachIndexed

fastEachReversed

fastRemoveIf

fastRemoveIfIndexed

fastRemoveIfReversed

clearing

addOrReplace

cut

_remove

allAre

first

first

last

equals

hashCode

copy

clone

toString