java.lang.Object
- fr.dufrenoy.util.SynchronizedChunkyList<E>

Type Parameters:

E - the type of elements in this list

All Implemented Interfaces:

ChunkyList<E>, Serializable, Iterable<E>, Collection<E>, List<E>
```
public class SynchronizedChunkyList<E>
extends Object
implements ChunkyList<E>, Serializable
```
A thread-safe implementation of ChunkyList, backed by an UnsynchronizedChunkyList and protected by a ReentrantReadWriteLock.
Multiple threads may read concurrently. Write operations are exclusive: a write blocks until all ongoing reads have completed, and blocks any new reads until the write is done.
The iterators returned by this class are fail-safe: iterator(), listIterator(), spliterator(), and Collection.stream() operate on a snapshot of the list taken at the time of the call, under a read lock. Subsequent modifications to the list are not reflected in the snapshot.
Memory note: snapshot-based operations (spliterator(), Collection.stream(), Collection.parallelStream(), iterator(), listIterator()) copy the entire list at the time of the call. Avoid calling them on very large lists in memory-constrained environments.

See Also:

Serialized Form

Nested Class Summary
- Nested classes/interfaces inherited from interface fr.dufrenoy.util.ChunkyList
  ChunkyList.GrowingStrategy, ChunkyList.ShrinkingStrategy

Constructor Summary

Constructors
Constructor	Description
`SynchronizedChunkyList()`	Creates a new `SynchronizedChunkyList` with the default chunk size.
`SynchronizedChunkyList(int chunkSize)`	Creates a new `SynchronizedChunkyList` with the given chunk size.
`SynchronizedChunkyList(int chunkSize, SynchronizedChunkyList<? extends E> other)`	Creates a copy of the given `SynchronizedChunkyList` with a different chunk size, preserving both strategies.
`SynchronizedChunkyList(int chunkSize, Collection<? extends E> c)`	Creates a new `SynchronizedChunkyList` with the given chunk size containing all elements of the given collection, in the order returned by its iterator.
`SynchronizedChunkyList(SynchronizedChunkyList<? extends E> other)`	Creates a faithful copy of the given `SynchronizedChunkyList`, preserving its chunk size, both strategies, and the internal chunk structure.
`SynchronizedChunkyList(Collection<? extends E> c)`	Creates a new `SynchronizedChunkyList` with the default chunk size containing all elements of the given collection, in the order returned by its iterator.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`void`	`add(int index, E element)`
`boolean`	`add(E e)`
`boolean`	`addAll(int index, Collection<? extends E> c)`
`boolean`	`addAll(Collection<? extends E> c)`
`void`	`clear()`
`boolean`	`contains(Object o)`
`boolean`	`containsAll(Collection<?> c)`
`boolean`	`equals(Object o)`
`void`	`forEach(Consumer<? super E> action)`
`E`	`get(int index)`
`int`	`getChunkSize()`	Returns the Chunksize, which is final, so no need for locking.
`ChunkyList.GrowingStrategy`	`getCurrentGrowingStrategy()`	Returns the current growing strategy.
`ChunkyList.ShrinkingStrategy`	`getCurrentShrinkingStrategy()`	Returns the current shrinking strategy.
`int`	`hashCode()`
`int`	`indexOf(Object o)`
`boolean`	`isEmpty()`
`Iterator<E>`	`iterator()`	Returns an iterator over a snapshot of this list taken under a read lock.
`int`	`lastIndexOf(Object o)`
`ListIterator<E>`	`listIterator()`	Returns a list iterator over a snapshot of this list taken under a read lock.
`ListIterator<E>`	`listIterator(int index)`	Returns a list iterator over a snapshot of this list taken under a read lock, starting at the given index.
`E`	`remove(int index)`
`boolean`	`remove(Object o)`
`boolean`	`removeAll(Collection<?> c)`
`boolean`	`removeIf(Predicate<? super E> filter)`
`void`	`reorganize()`	Reorganizes the list by redistributing all elements into full chunks, holding the write lock for the entire duration of the operation.
`void`	`reorganize(boolean blocking)`	Reorganizes the list by redistributing all elements into full chunks.
`void`	`replaceAll(UnaryOperator<E> operator)`
`boolean`	`retainAll(Collection<?> c)`
`E`	`set(int index, E element)`
`void`	`setCurrentGrowingStrategy(ChunkyList.GrowingStrategy growingStrategy)`	Sets the growing strategy.
`void`	`setCurrentShrinkingStrategy(ChunkyList.ShrinkingStrategy shrinkingStrategy)`	Sets the shrinking strategy.
`void`	`setStrategies(ChunkyList.GrowingStrategy growingStrategy, ChunkyList.ShrinkingStrategy shrinkingStrategy)`	Sets both strategies atomically under a single write lock, guaranteeing that no operation can observe an inconsistent intermediate state.
`int`	`size()`
`void`	`sort(Comparator<? super E> c)`
`Spliterator<E>`	`spliterator()`	Returns a `Spliterator` over a snapshot of this list taken under a read lock.
`List<E>`	`subList(int fromIndex, int toIndex)`
`Object[]`	`toArray()`
`<T> T[]`	`toArray(T[] a)`
`String`	`toString()`

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.util.Collection
parallelStream, stream, toArray

- Constructor Detail
  - SynchronizedChunkyList
```
public SynchronizedChunkyList()
```
    Creates a new SynchronizedChunkyList with the default chunk size.
  - SynchronizedChunkyList
```
public SynchronizedChunkyList(int chunkSize)
```
    Creates a new SynchronizedChunkyList with the given chunk size.
    
    Parameters:
    
    chunkSize - the number of elements per chunk; must be at least 1
  - SynchronizedChunkyList
```
public SynchronizedChunkyList(SynchronizedChunkyList<? extends E> other)
```
    Creates a faithful copy of the given SynchronizedChunkyList, preserving its chunk size, both strategies, and the internal chunk structure.
    A read lock is acquired on other for the duration of the copy, guaranteeing a consistent snapshot.
    
    Parameters:
    
    other - the list to copy
  - SynchronizedChunkyList
```
public SynchronizedChunkyList(int chunkSize,
                              SynchronizedChunkyList<? extends E> other)
```
    Creates a copy of the given SynchronizedChunkyList with a different chunk size, preserving both strategies.
    A read lock is acquired on other for the duration of the copy, guaranteeing a consistent snapshot.
    
    Parameters:
    
    chunkSize - the new chunk size; must be at least 1
    
    other - the list to copy
  - SynchronizedChunkyList
```
public SynchronizedChunkyList(Collection<? extends E> c)
```
    Creates a new SynchronizedChunkyList with the default chunk size containing all elements of the given collection, in the order returned by its iterator.
    
    Parameters:
    
    c - the collection whose elements are to be placed into this list
  - SynchronizedChunkyList
```
public SynchronizedChunkyList(int chunkSize,
                              Collection<? extends E> c)
```
    Creates a new SynchronizedChunkyList with the given chunk size containing all elements of the given collection, in the order returned by its iterator.
    
    Parameters:
    
    chunkSize - the number of elements per chunk; must be at least 1
    
    c - the collection whose elements are to be placed into this list
- Method Detail
  - getChunkSize
```
public int getChunkSize()
```
    Returns the Chunksize, which is final, so no need for locking.
    
    Specified by:
    
    getChunkSize in interface ChunkyList<E>
    
    Returns:
    
    the chunk size of this list
  - getCurrentGrowingStrategy
```
public ChunkyList.GrowingStrategy getCurrentGrowingStrategy()
```
    Description copied from interface: ChunkyList
    
    Returns the current growing strategy.
    
    Specified by:
    
    getCurrentGrowingStrategy in interface ChunkyList<E>
    
    Returns:
    
    the current growing strategy
    
    See Also:
    
    ChunkyList.GrowingStrategy
  - setCurrentGrowingStrategy
```
public void setCurrentGrowingStrategy(ChunkyList.GrowingStrategy growingStrategy)
```
    Description copied from interface: ChunkyList
    
    Sets the growing strategy. The new strategy applies immediately to all subsequent insertions.
    
    Specified by:
    
    setCurrentGrowingStrategy in interface ChunkyList<E>
    
    Parameters:
    
    growingStrategy - the new growing strategy
    
    See Also:
    
    ChunkyList.GrowingStrategy
  - getCurrentShrinkingStrategy
```
public ChunkyList.ShrinkingStrategy getCurrentShrinkingStrategy()
```
    Description copied from interface: ChunkyList
    
    Returns the current shrinking strategy.
    
    Specified by:
    
    getCurrentShrinkingStrategy in interface ChunkyList<E>
    
    Returns:
    
    the current shrinking strategy
    
    See Also:
    
    ChunkyList.ShrinkingStrategy
  - setCurrentShrinkingStrategy
```
public void setCurrentShrinkingStrategy(ChunkyList.ShrinkingStrategy shrinkingStrategy)
```
    Description copied from interface: ChunkyList
    
    Sets the shrinking strategy. The new strategy applies immediately to all subsequent removals.
    
    Specified by:
    
    setCurrentShrinkingStrategy in interface ChunkyList<E>
    
    Parameters:
    
    shrinkingStrategy - the new shrinking strategy
    
    See Also:
    
    ChunkyList.ShrinkingStrategy
  - setStrategies
```
public void setStrategies(ChunkyList.GrowingStrategy growingStrategy,
                          ChunkyList.ShrinkingStrategy shrinkingStrategy)
```
    Sets both strategies atomically under a single write lock, guaranteeing that no operation can observe an inconsistent intermediate state.
    
    Specified by:
    
    setStrategies in interface ChunkyList<E>
    
    Parameters:
    
    growingStrategy - the new growing strategy
    
    shrinkingStrategy - the new shrinking strategy
  - size
```
public int size()
```
    Specified by:
    
    size in interface Collection<E>
    
    Specified by:
    
    size in interface List<E>
  - isEmpty
```
public boolean isEmpty()
```
    Specified by:
    
    isEmpty in interface Collection<E>
    
    Specified by:
    
    isEmpty in interface List<E>
  - contains
```
public boolean contains(Object o)
```
    Specified by:
    
    contains in interface Collection<E>
    
    Specified by:
    
    contains in interface List<E>
  - containsAll
```
public boolean containsAll(Collection<?> c)
```
    Specified by:
    
    containsAll in interface Collection<E>
    
    Specified by:
    
    containsAll in interface List<E>
  - indexOf
```
public int indexOf(Object o)
```
    Specified by:
    
    indexOf in interface List<E>
  - lastIndexOf
```
public int lastIndexOf(Object o)
```
    Specified by:
    
    lastIndexOf in interface List<E>
  - get
```
public E get(int index)
```
    Specified by:
    
    get in interface List<E>
  - set
```
public E set(int index,
             E element)
```
    Specified by:
    
    set in interface List<E>
  - add
```
public boolean add(E e)
```
    Specified by:
    
    add in interface Collection<E>
    
    Specified by:
    
    add in interface List<E>
  - add
```
public void add(int index,
                E element)
```
    Specified by:
    
    add in interface List<E>
  - addAll
```
public boolean addAll(Collection<? extends E> c)
```
    Specified by:
    
    addAll in interface Collection<E>
    
    Specified by:
    
    addAll in interface List<E>
  - addAll
```
public boolean addAll(int index,
                      Collection<? extends E> c)
```
    Specified by:
    
    addAll in interface List<E>
  - remove
```
public boolean remove(Object o)
```
    Specified by:
    
    remove in interface Collection<E>
    
    Specified by:
    
    remove in interface List<E>
  - remove
```
public E remove(int index)
```
    Specified by:
    
    remove in interface List<E>
  - removeAll
```
public boolean removeAll(Collection<?> c)
```
    Specified by:
    
    removeAll in interface Collection<E>
    
    Specified by:
    
    removeAll in interface List<E>
  - removeIf
```
public boolean removeIf(Predicate<? super E> filter)
```
    Specified by:
    
    removeIf in interface Collection<E>
  - retainAll
```
public boolean retainAll(Collection<?> c)
```
    Specified by:
    
    retainAll in interface Collection<E>
    
    Specified by:
    
    retainAll in interface List<E>
  - replaceAll
```
public void replaceAll(UnaryOperator<E> operator)
```
    Specified by:
    
    replaceAll in interface List<E>
  - sort
```
public void sort(Comparator<? super E> c)
```
    Specified by:
    
    sort in interface List<E>
  - clear
```
public void clear()
```
    Specified by:
    
    clear in interface Collection<E>
    
    Specified by:
    
    clear in interface List<E>
  - subList
```
public List<E> subList(int fromIndex,
                       int toIndex)
```
    Specified by:
    
    subList in interface List<E>
  - toArray
```
public Object[] toArray()
```
    Specified by:
    
    toArray in interface Collection<E>
    
    Specified by:
    
    toArray in interface List<E>
  - toArray
```
public <T> T[] toArray(T[] a)
```
    Specified by:
    
    toArray in interface Collection<E>
    
    Specified by:
    
    toArray in interface List<E>
  - forEach
```
public void forEach(Consumer<? super E> action)
```
    Specified by:
    
    forEach in interface Iterable<E>
  - iterator
```
public Iterator<E> iterator()
```
    Returns an iterator over a snapshot of this list taken under a read lock.
    Memory note: this operation copies the entire list.
    
    Specified by:
    
    iterator in interface Collection<E>
    
    Specified by:
    
    iterator in interface Iterable<E>
    
    Specified by:
    
    iterator in interface List<E>
  - listIterator
```
public ListIterator<E> listIterator()
```
    Returns a list iterator over a snapshot of this list taken under a read lock.
    Memory note: this operation copies the entire list.
    
    Specified by:
    
    listIterator in interface List<E>
  - listIterator
```
public ListIterator<E> listIterator(int index)
```
    Returns a list iterator over a snapshot of this list taken under a read lock, starting at the given index.
    Memory note: this operation copies the entire list.
    
    Specified by:
    
    listIterator in interface List<E>
  - spliterator
```
public Spliterator<E> spliterator()
```
    Returns a Spliterator over a snapshot of this list taken under a read lock. The spliterator is Spliterator.ORDERED, Spliterator.SIZED, and Spliterator.SUBSIZED.
    Memory note: this operation copies the entire list.
    
    Specified by:
    
    spliterator in interface Collection<E>
    
    Specified by:
    
    spliterator in interface Iterable<E>
    
    Specified by:
    
    spliterator in interface List<E>
  - reorganize
```
public void reorganize()
```
    Reorganizes the list by redistributing all elements into full chunks, holding the write lock for the entire duration of the operation.
    No reads or writes can proceed while this method is running. This is the safe default; prefer it unless blocking is a concern.
    
    Specified by:
    
    reorganize in interface ChunkyList<E>
    
    See Also:
    
    reorganize(boolean)
  - reorganize
```
public void reorganize(boolean blocking)
```
    Reorganizes the list by redistributing all elements into full chunks.
    
    If blocking is true, behaves identically to reorganize(): the write lock is held for the entire operation.
    
    If blocking is false, uses a snapshot strategy: a copy of the list is taken under a read lock, reorganized without any lock, then swapped in under a write lock.
    Warning: any modifications made to the list between the snapshot and the final swap are silently lost. Use this mode only when the list is known to be quiescent or when occasional data loss is acceptable.
    Parameters:
    
    blocking - if true, holds the write lock for the full duration; if false, uses a non-blocking snapshot strategy
  - equals
```
public boolean equals(Object o)
```
    Specified by:
    
    equals in interface Collection<E>
    
    Specified by:
    
    equals in interface List<E>
    
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Specified by:
    
    hashCode in interface Collection<E>
    
    Specified by:
    
    hashCode in interface List<E>
    
    Overrides:
    
    hashCode in class Object
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object

Class SynchronizedChunkyList<E>

Nested Class Summary

Nested classes/interfaces inherited from interface fr.dufrenoy.util.ChunkyList

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.Collection

Constructor Detail

SynchronizedChunkyList

SynchronizedChunkyList

SynchronizedChunkyList

SynchronizedChunkyList

SynchronizedChunkyList

SynchronizedChunkyList

Method Detail

getChunkSize

getCurrentGrowingStrategy

setCurrentGrowingStrategy

getCurrentShrinkingStrategy

setCurrentShrinkingStrategy

setStrategies

size

isEmpty

contains

containsAll

indexOf

lastIndexOf

get

set

add

add

addAll

addAll

remove

remove

removeAll

removeIf

retainAll

replaceAll

sort

clear

subList

toArray

toArray

forEach

iterator

listIterator

listIterator

spliterator

reorganize

reorganize

equals

hashCode

toString