Class TreeSet<T>

java.lang.Object
io.vavr.collection.TreeSet<T>
Type Parameters:
T - Component type
All Implemented Interfaces:
Foldable<T>, Ordered<T>, Set<T>, SortedSet<T>, Traversable<T>, Function1<T,Boolean>, Value<T>, Serializable, Iterable<T>, Function<T,Boolean>
public final class TreeSet<T> extends Object implements SortedSet<T>, Serializable
SortedSet implementation, backed by a Red/Black Tree.
See Also:

  • Field Details

  • Constructor Details

  • Method Details

    • collector

      public static <T extends Comparable<? super T>> Collector<T, ArrayList<T>, TreeSet<T>> collector()
      Returns a Collector which may be used in conjunction with Stream.collect(java.util.stream.Collector) to obtain a TreeSet.

      The natural comparator is used to compare TreeSet elements.

      Type Parameters:
      T - Component type of the List.
      Returns:
      A io.vavr.collection.List Collector.

    • collector

      public static <T> Collector<T, ArrayList<T>, TreeSet<T>> collector(@NonNull Comparator<? super T> comparator)
      Returns a Collector which may be used in conjunction with Stream.collect(java.util.stream.Collector) to obtain a TreeSet.
      Type Parameters:
      T - Component type of the List.
      Parameters:
      comparator - An element comparator
      Returns:
      A io.vavr.collection.List Collector.

    • empty

      public static <T extends Comparable<? super T>> TreeSet<T> empty()
      Returns the empty TreeSet with natural ordering.
      Type Parameters:
      T - Component type
      Returns:
      The empty TreeSet with natural ordering.

    • empty

      public static <T> TreeSet<T> empty(@NonNull Comparator<? super T> comparator)
      Returns the empty TreeSet with the given comparator.
      Type Parameters:
      T - Component type
      Parameters:
      comparator - The comparator used to sort the elements
      Returns:
      The empty TreeSet.
      Throws:
      NullPointerException - if comparator is null

    • narrow

      public static <T> TreeSet<T> narrow(TreeSet<? extends T> treeSet)
      Narrows a TreeSet<? extends T> to TreeSet<T> via a type-safe cast. Safe here because the set is immutable and no elements can be added that would violate the type (covariance)

      CAUTION: The underlying Comparator might fail!

      Type Parameters:
      T - the target element type
      Parameters:
      treeSet - the set to narrow
      Returns:
      the same set viewed as TreeSet<T>

    • of

      public static <T extends Comparable<? super T>> TreeSet<T> of(T value)
      Returns a singleton TreeSet, i.e. a TreeSet of one element with natural ordering.
      Type Parameters:
      T - The component type
      Parameters:
      value - An element.
      Returns:
      A new TreeSet instance containing the given element

    • of

      public static <T> TreeSet<T> of(@NonNull Comparator<? super T> comparator, T value)
      Returns a singleton TreeSet, i.e. a TreeSet of one element with the given comparator.
      Type Parameters:
      T - The component type
      Parameters:
      comparator - The comparator used to sort the elements
      value - An element.
      Returns:
      A new TreeSet instance containing the given element
      Throws:
      NullPointerException - if comparator is null

    • of

      @SafeVarargs public static <T extends Comparable<? super T>> TreeSet<T> of(T @NonNull ... values)
      Creates a TreeSet of the given elements with natural ordering.
      Type Parameters:
      T - Component type of the TreeSet.
      Parameters:
      values - Zero or more elements.
      Returns:
      A set containing the given elements.
      Throws:
      NullPointerException - if values is null

    • of

      @SafeVarargs public static <T> TreeSet<T> of(@NonNull Comparator<? super T> comparator, T @NonNull ... values)
      Creates a TreeSet of the given elements with the given comparator.
      Type Parameters:
      T - Component type of the TreeSet.
      Parameters:
      comparator - The comparator used to sort the elements
      values - Zero or more elements.
      Returns:
      A set containing the given elements.
      Throws:
      NullPointerException - if comparator or values is null

    • tabulate

      public static <T> TreeSet<T> tabulate(@NonNull Comparator<? super T> comparator, int n, @NonNull Function<? super Integer, ? extends T> f)
      Returns a TreeSet containing n values of a given Function f over a range of integer values from 0 to n - 1.
      Type Parameters:
      T - Component type of the TreeSet
      Parameters:
      comparator - The comparator used to sort the elements
      n - The number of elements in the TreeSet
      f - The Function computing element values
      Returns:
      A TreeSet consisting of elements f(0),f(1), ..., f(n - 1)
      Throws:
      NullPointerException - if comparator or f are null

    • tabulate

      public static <T extends Comparable<? super T>> TreeSet<T> tabulate(int n, @NonNull Function<? super Integer, ? extends T> f)
      Returns a TreeSet containing n values of a given Function f over a range of integer values from 0 to n - 1. The underlying comparator is the natural comparator of T.
      Type Parameters:
      T - Component type of the TreeSet
      Parameters:
      n - The number of elements in the TreeSet
      f - The Function computing element values
      Returns:
      A TreeSet consisting of elements f(0),f(1), ..., f(n - 1)
      Throws:
      NullPointerException - if f is null

    • fill

      public static <T> TreeSet<T> fill(@NonNull Comparator<? super T> comparator, int n, @NonNull Supplier<? extends T> s)
      Returns a TreeSet containing tuples returned by n calls to a given Supplier s.
      Type Parameters:
      T - Component type of the TreeSet
      Parameters:
      comparator - The comparator used to sort the elements
      n - The number of elements in the TreeSet
      s - The Supplier computing element values
      Returns:
      A TreeSet of size n, where each element contains the result supplied by s.
      Throws:
      NullPointerException - if comparator or s are null

    • fill

      public static <T extends Comparable<? super T>> TreeSet<T> fill(int n, @NonNull Supplier<? extends T> s)
      Returns a TreeSet containing tuples returned by n calls to a given Supplier s. The underlying comparator is the natural comparator of T.
      Type Parameters:
      T - Component type of the TreeSet
      Parameters:
      n - The number of elements in the TreeSet
      s - The Supplier computing element values
      Returns:
      A TreeSet of size n, where each element contains the result supplied by s.
      Throws:
      NullPointerException - if s is null

    • ofAll

      public static <T extends Comparable<? super T>> TreeSet<T> ofAll(@NonNull Iterable<? extends T> values)
      Creates a TreeSet of the given elements with natural ordering.
      Type Parameters:
      T - Component type of the TreeSet.
      Parameters:
      values - An Iterable of elements.
      Returns:
      A set containing the given elements.
      Throws:
      NullPointerException - if values is null

    • ofAll

      public static <T> TreeSet<T> ofAll(Comparator<? super T> comparator, @NonNull Iterable<? extends T> values)
      Creates a TreeSet of the given elements with the given comparator.
      Type Parameters:
      T - Component type of the TreeSet.
      Parameters:
      comparator - The comparator used to sort the elements
      values - An Iterable of elements.
      Returns:
      A set containing the given elements.
      Throws:
      NullPointerException - if comparator or values is null

    • ofAll

      public static <T extends Comparable<? super T>> TreeSet<T> ofAll(@NonNull Stream<? extends T> javaStream)
      Creates a TreeSet from a Java Stream with natural ordering.
      Type Parameters:
      T - Component type of the TreeSet.
      Parameters:
      javaStream - A Java Stream
      Returns:
      A TreeSet containing the elements of the given stream
      Throws:
      NullPointerException - if javaStream is null

    • ofAll

      public static <T> TreeSet<T> ofAll(Comparator<? super T> comparator, @NonNull Stream<? extends T> javaStream)
      Creates a TreeSet from a Java Stream with the given comparator.
      Type Parameters:
      T - Component type of the TreeSet.
      Parameters:
      comparator - The comparator used to sort the elements
      javaStream - A Java Stream
      Returns:
      A TreeSet containing the elements of the given stream
      Throws:
      NullPointerException - if javaStream is null

    • ofAll

      public static TreeSet<Boolean> ofAll(boolean @NonNull ... elements)
      Creates a TreeSet from boolean values.
      Parameters:
      elements - boolean values
      Returns:
      A new TreeSet of Boolean values
      Throws:
      NullPointerException - if elements is null

    • ofAll

      public static TreeSet<Byte> ofAll(byte @NonNull ... elements)
      Creates a TreeSet from byte values.
      Parameters:
      elements - byte values
      Returns:
      A new TreeSet of Byte values
      Throws:
      NullPointerException - if elements is null

    • ofAll

      public static TreeSet<Character> ofAll(char @NonNull ... elements)
      Creates a TreeSet from char values.
      Parameters:
      elements - char values
      Returns:
      A new TreeSet of Character values
      Throws:
      NullPointerException - if elements is null

    • ofAll

      public static TreeSet<Double> ofAll(double @NonNull ... elements)
      Creates a TreeSet from double values.
      Parameters:
      elements - double values
      Returns:
      A new TreeSet of Double values
      Throws:
      NullPointerException - if elements is null

    • ofAll

      public static TreeSet<Float> ofAll(float @NonNull ... elements)
      Creates a TreeSet from float values.
      Parameters:
      elements - float values
      Returns:
      A new TreeSet of Float values
      Throws:
      NullPointerException - if elements is null

    • ofAll

      public static TreeSet<Integer> ofAll(int @NonNull ... elements)
      Creates a TreeSet from int values.
      Parameters:
      elements - int values
      Returns:
      A new TreeSet of Integer values
      Throws:
      NullPointerException - if elements is null

    • ofAll

      public static TreeSet<Long> ofAll(long @NonNull ... elements)
      Creates a TreeSet from long values.
      Parameters:
      elements - long values
      Returns:
      A new TreeSet of Long values
      Throws:
      NullPointerException - if elements is null

    • ofAll

      public static TreeSet<Short> ofAll(short @NonNull ... elements)
      Creates a TreeSet from short values.
      Parameters:
      elements - short values
      Returns:
      A new TreeSet of Short values
      Throws:
      NullPointerException - if elements is null

    • range

      public static TreeSet<Integer> range(int from, int toExclusive)
      Creates a TreeSet of int numbers starting from from, extending to toExclusive - 1.

      Examples: 

      
TreeSet.range(0, 0)  // = TreeSet()
TreeSet.range(2, 0)  // = TreeSet()
TreeSet.range(-2, 2) // = TreeSet(-2, -1, 0, 1)
      Parameters:
      from - the first number
      toExclusive - the last number + 1
      Returns:
      a range of int values as specified or the empty range if from >= toExclusive

    • range

      public static TreeSet<Character> range(char from, char toExclusive)
      Creates a TreeSet of char numbers starting from from, extending to toExclusive - 1.

      Examples: 

      
TreeSet.range('a', 'a')  // = TreeSet()
TreeSet.range('b', 'a')  // = TreeSet()
TreeSet.range('a', 'c')  // = TreeSet('a', 'b')
      Parameters:
      from - the first char
      toExclusive - the last char + 1
      Returns:
      a range of char values as specified or the empty range if from >= toExclusive

    • rangeBy

      public static TreeSet<Integer> rangeBy(int from, int toExclusive, int step)
      Creates a TreeSet of int numbers starting from from, extending to toExclusive - 1, with step.

      Examples: 

      
TreeSet.rangeBy(1, 3, 1)  // = TreeSet(1, 2)
TreeSet.rangeBy(1, 4, 2)  // = TreeSet(1, 3)
TreeSet.rangeBy(4, 1, -2) // = TreeSet(4, 2)
TreeSet.rangeBy(4, 1, 2)  // = TreeSet()
      Parameters:
      from - the first number
      toExclusive - the last number + 1
      step - the step
      Returns:
      a range of long values as specified or the empty range if
      from >= toInclusive and step > 0 or
      from <= toInclusive and step < 0
      Throws:
      IllegalArgumentException - if step is zero

    • rangeBy

      public static TreeSet<Character> rangeBy(char from, char toExclusive, int step)
      Creates a TreeSet of char numbers starting from from, extending to toExclusive - 1, with step.

      Examples: 

      
TreeSet.rangeBy('a', 'c', 1)  // = TreeSet('a', 'b')
TreeSet.rangeBy('a', 'd', 2)  // = TreeSet('a', 'c')
TreeSet.rangeBy('d', 'a', -2) // = TreeSet('d', 'b')
TreeSet.rangeBy('d', 'a', 2)  // = TreeSet()
      Parameters:
      from - the first char
      toExclusive - the last char + 1
      step - the step
      Returns:
      a range of char values as specified or the empty range if
      from >= toExclusive and step > 0 or
      from <= toExclusive and step < 0
      Throws:
      IllegalArgumentException - if step is zero

    • rangeBy

      @GwtIncompatible public static TreeSet<Double> rangeBy(double from, double toExclusive, double step)
      Creates a TreeSet of double numbers starting from from, extending up to (but not including) toExclusive, with step.

      Examples: 

      
TreeSet.rangeBy(1.0, 3.0, 1.0)  // = TreeSet(1.0, 2.0)
TreeSet.rangeBy(1.0, 4.0, 2.0)  // = TreeSet(1.0, 3.0)
TreeSet.rangeBy(4.0, 1.0, -2.0) // = TreeSet(4.0, 2.0)
TreeSet.rangeBy(4.0, 1.0, 2.0)  // = TreeSet()
      Parameters:
      from - the first double
      toExclusive - the upper bound (exclusive)
      step - the step
      Returns:
      a range of double values as specified or the empty range if
      from >= toExclusive and step > 0 or
      from <= toExclusive and step < 0
      Throws:
      IllegalArgumentException - if step is zero

    • range

      public static TreeSet<Long> range(long from, long toExclusive)
      Creates a TreeSet of long numbers starting from from, extending to toExclusive - 1.

      Examples: 

      
TreeSet.range(0L, 0L)  // = TreeSet()
TreeSet.range(2L, 0L)  // = TreeSet()
TreeSet.range(-2L, 2L) // = TreeSet(-2L, -1L, 0L, 1L)
      Parameters:
      from - the first number
      toExclusive - the last number + 1
      Returns:
      a range of long values as specified or the empty range if from >= toExclusive

    • rangeBy

      public static TreeSet<Long> rangeBy(long from, long toExclusive, long step)
      Creates a TreeSet of long numbers starting from from, extending to toExclusive - 1, with step.

      Examples: 

      
TreeSet.rangeBy(1L, 3L, 1L)  // = TreeSet(1L, 2L)
TreeSet.rangeBy(1L, 4L, 2L)  // = TreeSet(1L, 3L)
TreeSet.rangeBy(4L, 1L, -2L) // = TreeSet(4L, 2L)
TreeSet.rangeBy(4L, 1L, 2L)  // = TreeSet()
      Parameters:
      from - the first number
      toExclusive - the last number + 1
      step - the step
      Returns:
      a range of long values as specified or the empty range if
      from >= toInclusive and step > 0 or
      from <= toInclusive and step < 0
      Throws:
      IllegalArgumentException - if step is zero

    • rangeClosed

      public static TreeSet<Integer> rangeClosed(int from, int toInclusive)
      Creates a TreeSet of int numbers starting from from, extending to toInclusive.

      Examples: 

      
TreeSet.rangeClosed(0, 0)  // = TreeSet(0)
TreeSet.rangeClosed(2, 0)  // = TreeSet()
TreeSet.rangeClosed(-2, 2) // = TreeSet(-2, -1, 0, 1, 2)
      Parameters:
      from - the first number
      toInclusive - the last number
      Returns:
      a range of int values as specified or the empty range if from > toInclusive

    • rangeClosed

      public static TreeSet<Character> rangeClosed(char from, char toInclusive)
      Creates a TreeSet of char numbers starting from from, extending to toInclusive.

      Examples: 

      
TreeSet.rangeClosed('a', 'a')  // = TreeSet('a')
TreeSet.rangeClosed('b', 'a')  // = TreeSet()
TreeSet.rangeClosed('a', 'c')  // = TreeSet('a', 'b', 'c')
      Parameters:
      from - the first char
      toInclusive - the last char
      Returns:
      a range of char values as specified or the empty range if from > toInclusive

    • rangeClosedBy

      public static TreeSet<Integer> rangeClosedBy(int from, int toInclusive, int step)
      Creates a TreeSet of int numbers starting from from, extending to toInclusive, with step.

      Examples: 

      
TreeSet.rangeClosedBy(1, 3, 1)  // = TreeSet(1, 2, 3)
TreeSet.rangeClosedBy(1, 4, 2)  // = TreeSet(1, 3)
TreeSet.rangeClosedBy(4, 1, -2) // = TreeSet(4, 2)
TreeSet.rangeClosedBy(4, 1, 2)  // = TreeSet()
      Parameters:
      from - the first number
      toInclusive - the last number
      step - the step
      Returns:
      a range of int values as specified or the empty range if
      from > toInclusive and step > 0 or
      from < toInclusive and step < 0
      Throws:
      IllegalArgumentException - if step is zero

    • rangeClosedBy

      public static TreeSet<Character> rangeClosedBy(char from, char toInclusive, int step)
      Creates a TreeSet of char numbers starting from from, extending to toInclusive, with step.

      Examples: 

      
TreeSet.rangeClosedBy('a', 'c', 1)  // = TreeSet('a', 'b', 'c')
TreeSet.rangeClosedBy('a', 'd', 2)  // = TreeSet('a', 'c')
TreeSet.rangeClosedBy('d', 'a', -2) // = TreeSet('d', 'b')
TreeSet.rangeClosedBy('d', 'a', 2)  // = TreeSet()
      Parameters:
      from - the first char
      toInclusive - the last char
      step - the step
      Returns:
      a range of char values as specified or the empty range if
      from > toInclusive and step > 0 or
      from < toInclusive and step < 0
      Throws:
      IllegalArgumentException - if step is zero

    • rangeClosedBy

      @GwtIncompatible public static TreeSet<Double> rangeClosedBy(double from, double toInclusive, double step)
      Creates a TreeSet of double numbers starting from from, extending to toInclusive, with step.

      Examples: 

      
TreeSet.rangeClosedBy(1.0, 3.0, 1.0)  // = TreeSet(1.0, 2.0, 3.0)
TreeSet.rangeClosedBy(1.0, 4.0, 2.0)  // = TreeSet(1.0, 3.0)
TreeSet.rangeClosedBy(4.0, 1.0, -2.0) // = TreeSet(4.0, 2.0)
TreeSet.rangeClosedBy(4.0, 1.0, 2.0)  // = TreeSet()
      Parameters:
      from - the first double
      toInclusive - the last double
      step - the step
      Returns:
      a range of double values as specified or the empty range if
      from > toInclusive and step > 0 or
      from < toInclusive and step < 0
      Throws:
      IllegalArgumentException - if step is zero

    • rangeClosed

      public static TreeSet<Long> rangeClosed(long from, long toInclusive)
      Creates a TreeSet of long numbers starting from from, extending to toInclusive.

      Examples: 

      
TreeSet.rangeClosed(0L, 0L)  // = TreeSet(0L)
TreeSet.rangeClosed(2L, 0L)  // = TreeSet()
TreeSet.rangeClosed(-2L, 2L) // = TreeSet(-2L, -1L, 0L, 1L, 2L)
      Parameters:
      from - the first number
      toInclusive - the last number
      Returns:
      a range of long values as specified or the empty range if from > toInclusive

    • rangeClosedBy

      public static TreeSet<Long> rangeClosedBy(long from, long toInclusive, long step)
      Creates a TreeSet of long numbers starting from from, extending to toInclusive, with step.

      Examples: 

      
TreeSet.rangeClosedBy(1L, 3L, 1L)  // = TreeSet(1L, 2L, 3L)
TreeSet.rangeClosedBy(1L, 4L, 2L)  // = TreeSet(1L, 3L)
TreeSet.rangeClosedBy(4L, 1L, -2L) // = TreeSet(4L, 2L)
TreeSet.rangeClosedBy(4L, 1L, 2L)  // = TreeSet()
      Parameters:
      from - the first number
      toInclusive - the last number
      step - the step
      Returns:
      a range of int values as specified or the empty range if
      from > toInclusive and step > 0 or
      from < toInclusive and step < 0
      Throws:
      IllegalArgumentException - if step is zero

    • add

      public TreeSet<T> add(T element)
      Description copied from interface: Set
      Returns a new set containing all elements of this set plus the given element, if it was not already present.
      Specified by:
      add in interface Set<T>
      Specified by:
      add in interface SortedSet<T>
      Parameters:
      element - the element to add
      Returns:
      a new set including the element

    • addAll

      public TreeSet<T> addAll(@NonNull Iterable<? extends T> elements)
      Description copied from interface: Set
      Returns a new set containing all elements of this set plus the given elements, excluding duplicates.
      Specified by:
      addAll in interface Set<T>
      Specified by:
      addAll in interface SortedSet<T>
      Parameters:
      elements - the elements to add
      Returns:
      a new set including the additional elements

    • collect

      public <R> TreeSet<R> collect(@NonNull PartialFunction<? super T, ? extends R> partialFunction)
      Description copied from interface: Traversable
      Applies a PartialFunction to all elements that are defined for it and collects the results.

      For each element in iteration order, the function is first tested: 

      partialFunction.isDefinedAt(element)
      If true, the element is mapped to type R: 
      R newElement = partialFunction.apply(element)

      Note: If this Traversable is ordered (i.e., extends Ordered), the caller must ensure that the resulting elements are comparable (i.e., implement Comparable).

      Specified by:
      collect in interface Set<T>
      Specified by:
      collect in interface SortedSet<T>
      Specified by:
      collect in interface Traversable<T>
      Type Parameters:
      R - the type of elements in the resulting Traversable
      Parameters:
      partialFunction - a function that may not be defined for all elements of this traversable
      Returns:
      a new Traversable containing the results of applying the partial function

    • comparator

      public Comparator<T> comparator()
      Description copied from interface: Ordered
      Returns the comparator that governs the ordering of elements in this collection. The returned comparator must be consistent with the collection's iteration order.
      Specified by:
      comparator in interface Ordered<T>
      Returns:
      the comparator defining the element order

    • diff

      public TreeSet<T> diff(@NonNull Set<? extends T> elements)
      Description copied from interface: Set
      Returns a new set containing all elements of this set except those in the given set.
      Specified by:
      diff in interface Set<T>
      Specified by:
      diff in interface SortedSet<T>
      Parameters:
      elements - the set of elements to remove
      Returns:
      a new set without the specified elements

    • contains

      public boolean contains(T element)
      Description copied from interface: Value
      Shortcut for exists(e -> Objects.equals(e, element)), tests if the given element is contained.
      Specified by:
      contains in interface Set<T>
      Specified by:
      contains in interface Value<T>
      Parameters:
      element - An Object of type A, may be null.
      Returns:
      true, if element is contained, false otherwise.

    • distinct

      public TreeSet<T> distinct()
      Description copied from interface: Traversable
      Returns a new Traversable containing the elements of this instance with all duplicates removed. Element equality is determined using equals.
      Specified by:
      distinct in interface Set<T>
      Specified by:
      distinct in interface SortedSet<T>
      Specified by:
      distinct in interface Traversable<T>
      Returns:
      a new Traversable without duplicate elements

    • distinctBy

      public TreeSet<T> distinctBy(@NonNull Comparator<? super T> comparator)
      Description copied from interface: Traversable
      Returns a new Traversable containing the elements of this instance without duplicates, as determined by the given comparator.
      Specified by:
      distinctBy in interface Set<T>
      Specified by:
      distinctBy in interface SortedSet<T>
      Specified by:
      distinctBy in interface Traversable<T>
      Parameters:
      comparator - a comparator used to determine equality of elements
      Returns:
      a new Traversable with duplicates removed

    • distinctBy

      public <U> TreeSet<T> distinctBy(@NonNull Function<? super T, ? extends U> keyExtractor)
      Description copied from interface: Traversable
      Returns a new Traversable containing the elements of this instance without duplicates, based on keys extracted from elements using keyExtractor.

      The first occurrence of each key is retained in the resulting sequence.

      Specified by:
      distinctBy in interface Set<T>
      Specified by:
      distinctBy in interface SortedSet<T>
      Specified by:
      distinctBy in interface Traversable<T>
      Type Parameters:
      U - the type of key
      Parameters:
      keyExtractor - a function to extract keys for determining uniqueness
      Returns:
      a new Traversable with duplicates removed based on keys

    • drop

      public TreeSet<T> drop(int n)
      Description copied from interface: Traversable
      Returns a new Traversable without the first n elements, or an empty instance if this contains fewer than n elements.
      Specified by:
      drop in interface Set<T>
      Specified by:
      drop in interface SortedSet<T>
      Specified by:
      drop in interface Traversable<T>
      Parameters:
      n - the number of elements to drop
      Returns:
      a new instance excluding the first n elements

    • dropRight

      public TreeSet<T> dropRight(int n)
      Description copied from interface: Traversable
      Returns a new Traversable without the last n elements, or an empty instance if this contains fewer than n elements.
      Specified by:
      dropRight in interface Set<T>
      Specified by:
      dropRight in interface SortedSet<T>
      Specified by:
      dropRight in interface Traversable<T>
      Parameters:
      n - the number of elements to drop from the end
      Returns:
      a new instance excluding the last n elements

    • dropUntil

      public TreeSet<T> dropUntil(@NonNull Predicate<? super T> predicate)
      Description copied from interface: Traversable
      Returns a new Traversable starting from the first element that satisfies the given predicate, dropping all preceding elements.
      Specified by:
      dropUntil in interface Set<T>
      Specified by:
      dropUntil in interface SortedSet<T>
      Specified by:
      dropUntil in interface Traversable<T>
      Parameters:
      predicate - a condition tested on each element
      Returns:
      a new instance starting from the first element matching the predicate

    • dropWhile

      public TreeSet<T> dropWhile(@NonNull Predicate<? super T> predicate)
      Description copied from interface: Traversable
      Returns a new Traversable starting from the first element that does not satisfy the given predicate, dropping all preceding elements.

      This is equivalent to dropUntil(predicate.negate()), which is useful for method references that cannot be negated directly.

      Specified by:
      dropWhile in interface Set<T>
      Specified by:
      dropWhile in interface SortedSet<T>
      Specified by:
      dropWhile in interface Traversable<T>
      Parameters:
      predicate - a condition tested on each element
      Returns:
      a new instance starting from the first element not matching the predicate

    • filter

      public TreeSet<T> filter(@NonNull Predicate<? super T> predicate)
      Description copied from interface: Traversable
      Returns a new traversable containing only the elements that satisfy the given predicate.
      Specified by:
      filter in interface Set<T>
      Specified by:
      filter in interface SortedSet<T>
      Specified by:
      filter in interface Traversable<T>
      Parameters:
      predicate - the condition to test elements
      Returns:
      a traversable with elements matching the predicate

    • reject

      public TreeSet<T> reject(@NonNull Predicate<? super T> predicate)
      Description copied from interface: Traversable
      Returns a new traversable containing only the elements that do not satisfy the given predicate.

      This is equivalent to filter(predicate.negate()).

      Specified by:
      reject in interface Set<T>
      Specified by:
      reject in interface SortedSet<T>
      Specified by:
      reject in interface Traversable<T>
      Parameters:
      predicate - the condition to test elements
      Returns:
      a traversable with elements not matching the predicate

    • flatMap

      public <U> TreeSet<U> flatMap(@NonNull Comparator<? super U> comparator, @NonNull Function<? super T, ? extends Iterable<? extends U>> mapper)
      Description copied from interface: SortedSet
      Same as SortedSet.flatMap(Function) but using a specific comparator for values of the codomain of the given mapper.
      Specified by:
      flatMap in interface SortedSet<T>
      Type Parameters:
      U - Type of flat-mapped values
      Parameters:
      comparator - A comparator for values of type U
      mapper - A function which maps values of type T to Iterables of values of type U
      Returns:
      A new Set instance containing mapped values

    • flatMap

      public <U> TreeSet<U> flatMap(@NonNull Function<? super T, ? extends Iterable<? extends U>> mapper)
      Description copied from interface: Traversable
      Transforms each element of this Traversable into an Iterable of elements and flattens the resulting iterables into a single Traversable.
      Specified by:
      flatMap in interface Set<T>
      Specified by:
      flatMap in interface SortedSet<T>
      Specified by:
      flatMap in interface Traversable<T>
      Type Parameters:
      U - the type of elements in the resulting Traversable
      Parameters:
      mapper - a function mapping elements to iterables
      Returns:
      a new Traversable containing all elements produced by applying mapper and flattening

    • foldRight

      public <U> U foldRight(U zero, @NonNull BiFunction<? super T, ? super U, ? extends U> f)
      Description copied from interface: Foldable
      Folds the elements of this structure from the right, starting with the given zero value and successively applying the combine function to each element.

      Folding from the right means that elements are combined starting from the last element and associating each step with the accumulated result so far.

      Example: 

      // Result: "!cba"
List.of("a", "b", "c").foldRight("!", (x, acc) -> acc + x);
      Specified by:
      foldRight in interface Foldable<T>
      Specified by:
      foldRight in interface Traversable<T>
      Type Parameters:
      U - the type of the accumulated result
      Parameters:
      zero - the initial value to start folding with
      f - a function that combines the next element and the accumulated value
      Returns:
      the folded result

    • groupBy

      public <C> Map<C, TreeSet<T>> groupBy(@NonNull Function<? super T, ? extends C> classifier)
      Description copied from interface: Traversable
      Groups elements of this Traversable based on a classifier function.
      Specified by:
      groupBy in interface Set<T>
      Specified by:
      groupBy in interface SortedSet<T>
      Specified by:
      groupBy in interface Traversable<T>
      Type Parameters:
      C - The type of the group keys
      Parameters:
      classifier - A function that assigns each element to a group
      Returns:
      A map where each key corresponds to a group of elements
      See Also:

    • grouped

      public Iterator<TreeSet<T>> grouped(int size)
      Description copied from interface: Traversable
      Splits this Traversable into consecutive blocks of the given size.

      Let length be the number of elements in this Traversable:

      • If empty, the resulting Iterator is empty.
      • If size <= length, the resulting Iterator contains length / size blocks of size size and possibly a final smaller block of size length % size.
      • If size > length, the resulting Iterator contains a single block of size length.

      Examples:

      
[].grouped(1) = []
[].grouped(0) throws
[].grouped(-1) throws
[1,2,3,4].grouped(2) = [[1,2],[3,4]]
[1,2,3,4,5].grouped(2) = [[1,2],[3,4],[5]]
[1,2,3,4].grouped(5) = [[1,2,3,4]]

      Note: grouped(size) is equivalent to sliding(size, size).

      Specified by:
      grouped in interface Set<T>
      Specified by:
      grouped in interface SortedSet<T>
      Specified by:
      grouped in interface Traversable<T>
      Parameters:
      size - the block size; must be positive
      Returns:
      an Iterator over blocks of elements

    • hasDefiniteSize

      public boolean hasDefiniteSize()
      Description copied from interface: Traversable
      Indicates whether this Traversable has a known finite size.

      This should typically be implemented by concrete classes, not interfaces.

      Specified by:
      hasDefiniteSize in interface Traversable<T>
      Returns:
      true if the number of elements is finite and known, false otherwise.

    • head

      public T head()
      Description copied from interface: Traversable
      Returns the first element of this non-empty Traversable.
      Specified by:
      head in interface Traversable<T>
      Returns:
      the first element

    • headOption

      public Option<T> headOption()
      Description copied from interface: Traversable
      Returns the first element of this Traversable as an Option.
      Specified by:
      headOption in interface Traversable<T>
      Returns:
      Some(element) if non-empty, otherwise None

    • init

      public TreeSet<T> init()
      Description copied from interface: Traversable
      Returns all elements of this Traversable except the last one.

      This is the dual of Traversable.tail().

      Specified by:
      init in interface Set<T>
      Specified by:
      init in interface SortedSet<T>
      Specified by:
      init in interface Traversable<T>
      Returns:
      a new instance containing all elements except the last

    • initOption

      public Option<TreeSet<T>> initOption()
      Description copied from interface: Traversable
      Returns all elements of this Traversable except the last one, wrapped in an Option.

      This is the dual of Traversable.tailOption().

      Specified by:
      initOption in interface Set<T>
      Specified by:
      initOption in interface SortedSet<T>
      Specified by:
      initOption in interface Traversable<T>
      Returns:
      Some(traversable) if non-empty, or None if this Traversable is empty

    • intersect

      public TreeSet<T> intersect(@NonNull Set<? extends T> elements)
      Description copied from interface: Set
      Returns a new set containing only the elements present in both this set and the given set.
      Specified by:
      intersect in interface Set<T>
      Specified by:
      intersect in interface SortedSet<T>
      Parameters:
      elements - the set to intersect with
      Returns:
      a new set with elements common to both sets

    • isAsync

      public boolean isAsync()
      A TreeSet is computed synchronously.
      Specified by:
      isAsync in interface Value<T>
      Returns:
      false

    • isEmpty

      public boolean isEmpty()
      Description copied from interface: Traversable
      Checks if this Traversable contains no elements.
      Specified by:
      isEmpty in interface Traversable<T>
      Specified by:
      isEmpty in interface Value<T>
      Returns:
      true if empty, false otherwise

    • isLazy

      public boolean isLazy()
      A TreeSet is computed eagerly.
      Specified by:
      isLazy in interface Value<T>
      Returns:
      false

    • isTraversableAgain

      public boolean isTraversableAgain()
      Description copied from interface: Traversable
      Checks if this Traversable can be traversed multiple times without side effects.

      Implementations should provide the correct behavior; this is not meant for interfaces alone.

      Specified by:
      isTraversableAgain in interface Traversable<T>
      Returns:
      true if this Traversable is guaranteed to be repeatably traversable, false otherwise

    • iterator

      public @NonNull Iterator<T> iterator()
      Description copied from interface: Traversable
      Returns an iterator over the elements of this Traversable, implemented via Traversable.head() and Traversable.tail(). Subclasses may override for a more efficient implementation.
      Specified by:
      iterator in interface Iterable<T>
      Specified by:
      iterator in interface Set<T>
      Specified by:
      iterator in interface Traversable<T>
      Specified by:
      iterator in interface Value<T>
      Returns:
      a new Iterator over the elements of this Traversable

    • last

      public T last()
      Description copied from interface: Traversable
      Returns the last element of this Traversable.
      Specified by:
      last in interface Traversable<T>
      Returns:
      the last element

    • length

      public int length()
      Description copied from interface: Traversable
      Returns the number of elements in this Traversable.

      Equivalent to Traversable.size().

      Specified by:
      length in interface Set<T>
      Specified by:
      length in interface Traversable<T>
      Returns:
      the number of elements

    • map

      public <U> TreeSet<U> map(@NonNull Comparator<? super U> comparator, @NonNull Function<? super T, ? extends U> mapper)
      Description copied from interface: SortedSet
      Same as SortedSet.map(Function) but using a specific comparator for values of the codomain of the given mapper.
      Specified by:
      map in interface SortedSet<T>
      Type Parameters:
      U - Type of mapped values
      Parameters:
      comparator - A comparator for values of type U
      mapper - A function which maps values of type T to values of type U
      Returns:
      A new Set instance containing mapped values

    • map

      public <U> TreeSet<U> map(@NonNull Function<? super T, ? extends U> mapper)
      Description copied from interface: Traversable
      Transforms the elements of this Traversable to a new type, preserving order if defined.
      Specified by:
      map in interface Set<T>
      Specified by:
      map in interface SortedSet<T>
      Specified by:
      map in interface Traversable<T>
      Specified by:
      map in interface Value<T>
      Type Parameters:
      U - the target element type
      Parameters:
      mapper - a mapping function
      Returns:
      a new Traversable containing the mapped elements

    • mapTo

      public <U> TreeSet<U> mapTo(U value)
      Description copied from interface: Value
      Maps the underlying value to another fixed value.
      Specified by:
      mapTo in interface Set<T>
      Specified by:
      mapTo in interface SortedSet<T>
      Specified by:
      mapTo in interface Traversable<T>
      Specified by:
      mapTo in interface Value<T>
      Type Parameters:
      U - The new component type
      Parameters:
      value - value to replace the contents with
      Returns:
      A new value

    • mapToVoid

      public TreeSet<Void> mapToVoid()
      Description copied from interface: Value
      Maps the underlying value to Void
      Specified by:
      mapToVoid in interface Set<T>
      Specified by:
      mapToVoid in interface SortedSet<T>
      Specified by:
      mapToVoid in interface Traversable<T>
      Specified by:
      mapToVoid in interface Value<T>
      Returns:
      A new value of type Void

    • orElse

      public TreeSet<T> orElse(@NonNull Iterable<? extends T> other)
      Returns this TreeSet if it is nonempty, otherwise TreeSet created from iterable, using existing comparator.
      Specified by:
      orElse in interface Set<T>
      Specified by:
      orElse in interface SortedSet<T>
      Specified by:
      orElse in interface Traversable<T>
      Parameters:
      other - An alternative Traversable
      Returns:
      this TreeSet if it is nonempty, otherwise TreeSet created from iterable, using existing comparator.

    • orElse

      public TreeSet<T> orElse(@NonNull Supplier<? extends Iterable<? extends T>> supplier)
      Returns this TreeSet if it is nonempty, otherwise TreeSet created from result of evaluating supplier, using existing comparator.
      Specified by:
      orElse in interface Set<T>
      Specified by:
      orElse in interface SortedSet<T>
      Specified by:
      orElse in interface Traversable<T>
      Parameters:
      supplier - An alternative Traversable
      Returns:
      this TreeSet if it is nonempty, otherwise TreeSet created from result of evaluating supplier, using existing comparator.

    • partition

      public Tuple2<TreeSet<T>, TreeSet<T>> partition(@NonNull Predicate<? super T> predicate)
      Description copied from interface: Traversable
      Splits this Traversable into two partitions according to a predicate.

      The first partition contains all elements that satisfy the predicate, and the second contains all elements that do not. The original iteration order is preserved.

      Specified by:
      partition in interface Set<T>
      Specified by:
      partition in interface SortedSet<T>
      Specified by:
      partition in interface Traversable<T>
      Parameters:
      predicate - a predicate used to classify elements
      Returns:
      a Tuple2 containing the two resulting Traversable instances

    • peek

      public TreeSet<T> peek(@NonNull Consumer<? super T> action)
      Description copied from interface: Value
      Performs the given action on the first element if this is an eager implementation. Performs the given action on all elements (the first immediately, successive deferred), if this is a lazy implementation.
      Specified by:
      peek in interface Set<T>
      Specified by:
      peek in interface SortedSet<T>
      Specified by:
      peek in interface Traversable<T>
      Specified by:
      peek in interface Value<T>
      Parameters:
      action - The action that will be performed on the element(s).
      Returns:
      this instance

    • remove

      public TreeSet<T> remove(T element)
      Description copied from interface: Set
      Returns a new set with the given element removed, if it was present.
      Specified by:
      remove in interface Set<T>
      Specified by:
      remove in interface SortedSet<T>
      Parameters:
      element - the element to remove
      Returns:
      a new set without the specified element

    • removeAll

      public TreeSet<T> removeAll(@NonNull Iterable<? extends T> elements)
      Description copied from interface: Set
      Returns a new set with all given elements removed, if present.
      Specified by:
      removeAll in interface Set<T>
      Specified by:
      removeAll in interface SortedSet<T>
      Parameters:
      elements - the elements to remove
      Returns:
      a new set without the specified elements

    • replace

      public TreeSet<T> replace(T currentElement, T newElement)
      Description copied from interface: Traversable
      Replaces the first occurrence of currentElement with newElement, if it exists.
      Specified by:
      replace in interface Set<T>
      Specified by:
      replace in interface SortedSet<T>
      Specified by:
      replace in interface Traversable<T>
      Parameters:
      currentElement - the element to be replaced
      newElement - the replacement element
      Returns:
      a new Traversable with the first occurrence of currentElement replaced by newElement

    • replaceAll

      public TreeSet<T> replaceAll(T currentElement, T newElement)
      Description copied from interface: Traversable
      Replaces all occurrences of currentElement with newElement.
      Specified by:
      replaceAll in interface Set<T>
      Specified by:
      replaceAll in interface SortedSet<T>
      Specified by:
      replaceAll in interface Traversable<T>
      Parameters:
      currentElement - the element to be replaced
      newElement - the replacement element
      Returns:
      a new Traversable with all occurrences of currentElement replaced by newElement

    • retainAll

      public TreeSet<T> retainAll(@NonNull Iterable<? extends T> elements)
      Description copied from interface: Traversable
      Retains only the elements from this Traversable that are contained in the given elements.
      Specified by:
      retainAll in interface Set<T>
      Specified by:
      retainAll in interface SortedSet<T>
      Specified by:
      retainAll in interface Traversable<T>
      Parameters:
      elements - the elements to keep
      Returns:
      a new Traversable containing only the elements present in elements, in their original order

    • scan

      public TreeSet<T> scan(T zero, @NonNull BiFunction<? super T, ? super T, ? extends T> operation)
      Description copied from interface: Traversable
      Computes a prefix scan of the elements of this Traversable.

      The neutral element zero may be applied more than once.

      Specified by:
      scan in interface Set<T>
      Specified by:
      scan in interface SortedSet<T>
      Specified by:
      scan in interface Traversable<T>
      Parameters:
      zero - the neutral element for the operator
      operation - an associative binary operator
      Returns:
      a new Traversable containing the prefix scan of the elements

    • scanLeft

      public <U> Set<U> scanLeft(U zero, @NonNull BiFunction<? super U, ? super T, ? extends U> operation)
      Description copied from interface: Traversable
      Produces a collection containing cumulative results of applying the operator from left to right.

      Will not terminate for infinite collections. The results may vary across runs unless the collection is ordered.

      Specified by:
      scanLeft in interface Set<T>
      Specified by:
      scanLeft in interface SortedSet<T>
      Specified by:
      scanLeft in interface Traversable<T>
      Type Parameters:
      U - the type of the resulting elements
      Parameters:
      zero - the initial value
      operation - a binary operator applied to the intermediate result and each element
      Returns:
      a new Traversable containing the cumulative results

    • scanRight

      public <U> Set<U> scanRight(U zero, @NonNull BiFunction<? super T, ? super U, ? extends U> operation)
      Description copied from interface: Traversable
      Produces a collection containing cumulative results of applying the operator from right to left.

      The head of the resulting collection is the last cumulative result. Will not terminate for infinite collections. Results may vary across runs unless the collection is ordered.

      Specified by:
      scanRight in interface Set<T>
      Specified by:
      scanRight in interface SortedSet<T>
      Specified by:
      scanRight in interface Traversable<T>
      Type Parameters:
      U - the type of the resulting elements
      Parameters:
      zero - the initial value
      operation - a binary operator applied to each element and the intermediate result
      Returns:
      a new Traversable containing the cumulative results

    • slideBy

      public Iterator<TreeSet<T>> slideBy(@NonNull Function<? super T, ?> classifier)
      Description copied from interface: Traversable
      Partitions this Traversable into consecutive non-overlapping windows according to a classification function.

      Each window contains elements with the same class, as determined by classifier. Two consecutive elements belong to the same window only if classifier returns equal values for both. Otherwise, the current window ends and a new window begins with the next element.

      Examples: 

      [].slideBy(Function.identity()) = []
[1,2,3,4,4,5].slideBy(Function.identity()) = [[1],[2],[3],[4,4],[5]]
[1,2,3,10,12,5,7,20,29].slideBy(x -> x / 10) = [[1,2,3],[10,12],[5,7],[20,29]]
      Specified by:
      slideBy in interface Set<T>
      Specified by:
      slideBy in interface SortedSet<T>
      Specified by:
      slideBy in interface Traversable<T>
      Parameters:
      classifier - A function classifying elements into groups
      Returns:
      An Iterator of windows (grouped elements)

    • sliding

      public Iterator<TreeSet<T>> sliding(int size)
      Description copied from interface: Traversable
      Slides a window of a given size over this Traversable with a step size of 1.

      This is equivalent to calling Traversable.sliding(int, int) with a step size of 1.

      Specified by:
      sliding in interface Set<T>
      Specified by:
      sliding in interface SortedSet<T>
      Specified by:
      sliding in interface Traversable<T>
      Parameters:
      size - a positive window size
      Returns:
      An Iterator of windows, each containing up to size elements

    • sliding

      public Iterator<TreeSet<T>> sliding(int size, int step)
      Description copied from interface: Traversable
      Slides a window of a specific size with a given step over this Traversable.

      Examples: 

      [].sliding(1, 1) = []
[1,2,3,4,5].sliding(2, 3) = [[1,2],[4,5]]
[1,2,3,4,5].sliding(2, 4) = [[1,2],[5]]
[1,2,3,4,5].sliding(2, 5) = [[1,2]]
[1,2,3,4].sliding(5, 3) = [[1,2,3,4],[4]]
      Specified by:
      sliding in interface Set<T>
      Specified by:
      sliding in interface SortedSet<T>
      Specified by:
      sliding in interface Traversable<T>
      Parameters:
      size - a positive window size
      step - a positive step size
      Returns:
      an Iterator of windows with the given size and step

    • span

      public Tuple2<TreeSet<T>, TreeSet<T>> span(@NonNull Predicate<? super T> predicate)
      Description copied from interface: Traversable
      Splits this Traversable into a prefix and remainder according to the given predicate.

      The first element of the returned Tuple is the longest prefix of elements satisfying predicate, and the second element is the remaining elements.

      Specified by:
      span in interface Set<T>
      Specified by:
      span in interface SortedSet<T>
      Specified by:
      span in interface Traversable<T>
      Parameters:
      predicate - a predicate used to determine the prefix
      Returns:
      a Tuple containing the prefix and remainder

    • tail

      public TreeSet<T> tail()
      Description copied from interface: Traversable
      Returns a new Traversable without its first element.
      Specified by:
      tail in interface Set<T>
      Specified by:
      tail in interface SortedSet<T>
      Specified by:
      tail in interface Traversable<T>
      Returns:
      a new Traversable containing all elements except the first

    • tailOption

      public Option<TreeSet<T>> tailOption()
      Description copied from interface: Traversable
      Returns a new Traversable without its first element as an Option.
      Specified by:
      tailOption in interface Set<T>
      Specified by:
      tailOption in interface SortedSet<T>
      Specified by:
      tailOption in interface Traversable<T>
      Returns:
      Some(traversable) if non-empty, otherwise None

    • take

      public TreeSet<T> take(int n)
      Description copied from interface: Traversable
      Returns the first n elements of this Traversable, or all elements if n exceeds the length.

      Equivalent to sublist(0, max(0, min(length(), n))), but safe for n < 0 or n > length().

      If n < 0, an empty instance is returned. If n > length(), the full instance is returned.

      Specified by:
      take in interface Set<T>
      Specified by:
      take in interface SortedSet<T>
      Specified by:
      take in interface Traversable<T>
      Parameters:
      n - the number of elements to take
      Returns:
      a new Traversable containing the first n elements

    • takeRight

      public TreeSet<T> takeRight(int n)
      Description copied from interface: Traversable
      Returns the last n elements of this Traversable, or all elements if n exceeds the length.

      Equivalent to sublist(max(0, length() - n), length()), but safe for n < 0 or n > length().

      If n < 0, an empty instance is returned. If n > length(), the full instance is returned.

      Specified by:
      takeRight in interface Set<T>
      Specified by:
      takeRight in interface SortedSet<T>
      Specified by:
      takeRight in interface Traversable<T>
      Parameters:
      n - the number of elements to take from the end
      Returns:
      a new Traversable containing the last n elements

    • takeUntil

      public TreeSet<T> takeUntil(@NonNull Predicate<? super T> predicate)
      Description copied from interface: Traversable
      Takes elements from this Traversable until the given predicate holds for an element.

      Equivalent to takeWhile(predicate.negate()), but useful when using method references that cannot be negated directly.

      Specified by:
      takeUntil in interface Set<T>
      Specified by:
      takeUntil in interface SortedSet<T>
      Specified by:
      takeUntil in interface Traversable<T>
      Parameters:
      predicate - a condition tested sequentially on the elements
      Returns:
      a new Traversable containing all elements before the first one that satisfies the predicate

    • takeWhile

      public TreeSet<T> takeWhile(@NonNull Predicate<? super T> predicate)
      Description copied from interface: Traversable
      Takes elements from this Traversable while the given predicate holds.
      Specified by:
      takeWhile in interface Set<T>
      Specified by:
      takeWhile in interface SortedSet<T>
      Specified by:
      takeWhile in interface Traversable<T>
      Parameters:
      predicate - a condition tested sequentially on the elements
      Returns:
      a new Traversable containing all elements up to (but not including) the first one that does not satisfy the predicate

    • transform

      public <U> U transform(Function<? super TreeSet<T>, ? extends U> f)
      Transforms this TreeSet.
      Type Parameters:
      U - Type of transformation result
      Parameters:
      f - A transformation
      Returns:
      An instance of type U
      Throws:
      NullPointerException - if f is null

    • toJavaSet

      public TreeSet<T> toJavaSet()
      Description copied from interface: Set
      Converts this Vavr set to a java.util.Set, preserving insertion or sort order.
      Specified by:
      toJavaSet in interface Set<T>
      Specified by:
      toJavaSet in interface SortedSet<T>
      Specified by:
      toJavaSet in interface Value<T>
      Returns:
      a new java.util.Set instance

    • union

      public TreeSet<T> union(@NonNull Set<? extends T> elements)
      Description copied from interface: Set
      Returns a new set containing all distinct elements from this set and the given set.
      Specified by:
      union in interface Set<T>
      Specified by:
      union in interface SortedSet<T>
      Parameters:
      elements - the set to union with
      Returns:
      a new set with all elements from both sets

    • unzip

      public <T1,T2> Tuple2<TreeSet<T1>, TreeSet<T2>> unzip(@NonNull Function<? super T, Tuple2<? extends T1, ? extends T2>> unzipper)
      Description copied from interface: Traversable
      Unzips the elements of this Traversable by mapping each element to a pair and splitting them into two separate Traversable collections.
      Specified by:
      unzip in interface Set<T>
      Specified by:
      unzip in interface SortedSet<T>
      Specified by:
      unzip in interface Traversable<T>
      Type Parameters:
      T1 - type of the first element in the resulting pairs
      T2 - type of the second element in the resulting pairs
      Parameters:
      unzipper - a function that maps elements of this Traversable to pairs
      Returns:
      a Tuple2 containing two Traversable collections with the split elements

    • unzip3

      public <T1,T2,T3> Tuple3<TreeSet<T1>, TreeSet<T2>, TreeSet<T3>> unzip3(@NonNull Function<? super T, Tuple3<? extends T1, ? extends T2, ? extends T3>> unzipper)
      Description copied from interface: Traversable
      Unzips the elements of this Traversable by mapping each element to a triple and splitting them into three separate Traversable collections.
      Specified by:
      unzip3 in interface Set<T>
      Specified by:
      unzip3 in interface SortedSet<T>
      Specified by:
      unzip3 in interface Traversable<T>
      Type Parameters:
      T1 - type of the first element in the resulting triples
      T2 - type of the second element in the resulting triples
      T3 - type of the third element in the resulting triples
      Parameters:
      unzipper - a function that maps elements of this Traversable to triples
      Returns:
      a Tuple3 containing three Traversable collections with the split elements

    • zip

      public <U> TreeSet<Tuple2<T,U>> zip(@NonNull Iterable<? extends U> that)
      Description copied from interface: Traversable
      Returns a Traversable formed by pairing elements of this Traversable with elements of another Iterable. Pairing stops when either collection runs out of elements; any remaining elements in the longer collection are ignored.

      The length of the resulting Traversable is the minimum of the lengths of this Traversable and that.

      Specified by:
      zip in interface Set<T>
      Specified by:
      zip in interface SortedSet<T>
      Specified by:
      zip in interface Traversable<T>
      Type Parameters:
      U - the type of elements in the second half of each pair
      Parameters:
      that - an Iterable providing the second element of each pair
      Returns:
      a new Traversable containing pairs of corresponding elements

    • zipWith

      public <U,R> TreeSet<R> zipWith(@NonNull Iterable<? extends U> that, BiFunction<? super T, ? super U, ? extends R> mapper)
      Description copied from interface: Traversable
      Returns a Traversable by combining elements of this Traversable with elements of another Iterable using a mapping function. Pairing stops when either collection runs out of elements.

      The length of the resulting Traversable is the minimum of the lengths of this Traversable and that.

      Specified by:
      zipWith in interface Set<T>
      Specified by:
      zipWith in interface SortedSet<T>
      Specified by:
      zipWith in interface Traversable<T>
      Type Parameters:
      U - the type of elements in the second parameter of the mapper
      R - the type of elements in the resulting Traversable
      Parameters:
      that - an Iterable providing the second parameter of the mapper
      mapper - a function that combines elements from this and that into a new element
      Returns:
      a new Traversable containing mapped elements

    • zipAll

      public <U> TreeSet<Tuple2<T,U>> zipAll(@NonNull Iterable<? extends U> that, T thisElem, U thatElem)
      Description copied from interface: Traversable
      Returns a Traversable formed by pairing elements of this Traversable with elements of another Iterable, filling in placeholder elements when one collection is shorter than the other.

      The length of the resulting Traversable is the maximum of the lengths of this Traversable and that.

      If this Traversable is shorter than that, thisElem is used as a filler. Conversely, if that is shorter, thatElem is used.

      Specified by:
      zipAll in interface Set<T>
      Specified by:
      zipAll in interface SortedSet<T>
      Specified by:
      zipAll in interface Traversable<T>
      Type Parameters:
      U - the type of elements in the second half of each pair
      Parameters:
      that - an Iterable providing the second element of each pair
      thisElem - the element used to fill missing values if this Traversable is shorter than that
      thatElem - the element used to fill missing values if that is shorter than this Traversable
      Returns:
      a new Traversable containing pairs of elements, including fillers as needed

    • zipWithIndex

      public TreeSet<Tuple2<T,Integer>> zipWithIndex()
      Description copied from interface: Traversable
      Zips this Traversable with its indices, starting at 0.
      Specified by:
      zipWithIndex in interface Set<T>
      Specified by:
      zipWithIndex in interface SortedSet<T>
      Specified by:
      zipWithIndex in interface Traversable<T>
      Returns:
      a new Traversable containing each element paired with its index

    • zipWithIndex

      public <U> SortedSet<U> zipWithIndex(@NonNull BiFunction<? super T, ? super Integer, ? extends U> mapper)
      Description copied from interface: Traversable
      Zips this Traversable with its indices and maps the resulting pairs using the provided mapper.
      Specified by:
      zipWithIndex in interface Set<T>
      Specified by:
      zipWithIndex in interface SortedSet<T>
      Specified by:
      zipWithIndex in interface Traversable<T>
      Type Parameters:
      U - the type of elements in the resulting Traversable
      Parameters:
      mapper - a function mapping an element and its index to a new element
      Returns:
      a new Traversable containing the mapped elements

    • equals

      public boolean equals(Object o)
      Description copied from interface: Traversable
      Determines whether this collection is equal to the given object.

      In Vavr, there are four basic collection types:

      • Seq – sequential elements
      • Set – distinct elements
      • Map – key-value pairs
      • Multimap – keys mapped to multiple values
      Two collections are considered equal if and only if:
      • They are of the same collection type (Seq, Set, Map, Multimap)
      • They contain the same elements
      • For Seq, the element order is the same

      For Map and Multimap, two entries (key1, value1) and (key2, value2) are equal if both their keys and values are equal.

      Additional notes:

      • No collection equals null (e.g., Queue(1) != null)
      • Null elements are allowed and treated as expected (e.g., List(null, 1) == Stream(null, 1), HashMap((null,1)) == LinkedHashMap((null,1)))
      • Element order matters only for Seq
      • Other collection classes are equal if their types and elements (in iteration order) are equal
      • Iterators are compared by reference only
      Specified by:
      equals in interface Traversable<T>
      Specified by:
      equals in interface Value<T>
      Overrides:
      equals in class Object
      Parameters:
      o - the object to compare with, may be null
      Returns:
      true if the collections are equal according to the rules above, false otherwise

    • hashCode

      public int hashCode()
      Description copied from interface: Traversable
      Returns the hash code of this collection.

      Vavr distinguishes between collections with predictable iteration order (like Seq) and collections with arbitrary iteration order (like Set, Map, and Multimap). In all cases, the hash of an empty collection is defined as 1.

      For collections with predictable iteration order, the hash is computed as:

      int hash = 1;
for (T t : this) {
    hash = hash * 31 + Objects.hashCode(t);
}

      For collections with arbitrary iteration order, the hash is computed to be independent of element order:

      int hash = 1;
for (T t : this) {
    hash += Objects.hashCode(t);
}

      Note that these algorithms may change in future Vavr versions. Hash codes are generally not cached, unlike size/length, because caching would increase memory usage due to persistent tree-based structures. Computing the hash code is linear in time, O(n). For frequently re-used collections (e.g., as HashMap keys), caching can be done externally using a wrapper, for example:

      public final class Hashed<K> {
    private final K key;
    private final Lazy<Integer> hashCode;

    public Hashed(K key) {
        this.key = key;
        this.hashCode = Lazy.of(() -> Objects.hashCode(key));
    }

    public K key() { return key; }

    @Override
    public boolean equals(Object o) {
        if (o == key) return true;
        if (key != null && o instanceof Hashed) return key.equals(((Hashed<?>) o).key);
        return false;
    }

    @Override
    public int hashCode() { return hashCode.get(); }

    @Override
    public String toString() { return "Hashed(" + key + ")"; }
}
      Specified by:
      hashCode in interface Traversable<T>
      Specified by:
      hashCode in interface Value<T>
      Overrides:
      hashCode in class Object
      Returns:
      the hash code of this collection

    • stringPrefix

      public String stringPrefix()
      Description copied from interface: Value
      Returns the name of this Value type, which is used by toString().
      Specified by:
      stringPrefix in interface Value<T>
      Returns:
      This type name.

    • toString

      public String toString()
      Description copied from interface: Value
      Clarifies that values have a proper toString() method implemented.

      See Object.toString().

      Specified by:
      toString in interface Value<T>
      Overrides:
      toString in class Object
      Returns:
      A String representation of this object