Package io.vavr.collection

Class LinkedHashSet<T>

java.lang.Object
io.vavr.collection.LinkedHashSet<T>
Type Parameters:
T - Component type
All Implemented Interfaces:
Foldable<T>, Set<T>, Traversable<T>, Function1<T,Boolean>, Value<T>, Serializable, Iterable<T>, Function<T,Boolean>
public final class LinkedHashSet<T> extends Object implements Set<T>, Serializable
An immutable HashSet implementation that has predictable (insertion-order) iteration.
See Also:

  • Field Details

  • Constructor Details

  • Method Details

    • empty

      public static <T> LinkedHashSet<T> empty()
      Returns the empty LinkedHashSet.
      Type Parameters:
      T - Component type
      Returns:
      The empty LinkedHashSet.

    • wrap

      static <T> LinkedHashSet<T> wrap(LinkedHashMap<T,Object> map)

    • collector

      public static <T> Collector<T,ArrayList<T>,LinkedHashSet<T>> collector()
      Returns a Collector which may be used in conjunction with Stream.collect(Collector) to obtain a LinkedHashSet.
      Type Parameters:
      T - Component type of the LinkedHashSet.
      Returns:
      A io.vavr.collection.LinkedHashSet Collector.

    • narrow

      public static <T> LinkedHashSet<T> narrow(LinkedHashSet<? extends T> linkedHashSet)
      Narrows a LinkedHashSet<? extends T> to LinkedHashSet<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)
      Type Parameters:
      T - the target element type
      Parameters:
      linkedHashSet - the set to narrow
      Returns:
      the same set viewed as LinkedHashSet<T>

    • of

      public static <T> LinkedHashSet<T> of(T element)
      Returns a singleton LinkedHashSet, i.e. a LinkedHashSet of one element.
      Type Parameters:
      T - The component type
      Parameters:
      element - An element.
      Returns:
      A new LinkedHashSet instance containing the given element

    • of

      @SafeVarargs public static <T> LinkedHashSet<T> of(T @NonNull ... elements)
      Creates a LinkedHashSet of the given elements. 
      LinkedHashSet.of(1, 2, 3, 4)
      Type Parameters:
      T - Component type of the LinkedHashSet.
      Parameters:
      elements - Zero or more elements.
      Returns:
      A set containing the given elements.
      Throws:
      NullPointerException - if elements is null

    • tabulate

      public static <T> LinkedHashSet<T> tabulate(int n, @NonNull Function<? super Integer,? extends T> f)
      Returns a LinkedHashSet 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 LinkedHashSet
      Parameters:
      n - The number of elements in the LinkedHashSet
      f - The Function computing element values
      Returns:
      A LinkedHashSet consisting of elements f(0),f(1), ..., f(n - 1)
      Throws:
      NullPointerException - if f is null

    • fill

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

    • ofAll

      public static <T> LinkedHashSet<T> ofAll(@NonNull Iterable<? extends T> elements)
      Creates a LinkedHashSet of the given elements.
      Type Parameters:
      T - The value type
      Parameters:
      elements - Set elements
      Returns:
      A new LinkedHashSet containing the given entries

    • ofAll

      public static <T> LinkedHashSet<T> ofAll(@NonNull Stream<? extends T> javaStream)
      Creates a LinkedHashSet that contains the elements of the given Stream.
      Type Parameters:
      T - Component type of the Stream.
      Parameters:
      javaStream - A Stream
      Returns:
      A LinkedHashSet containing the given elements in the same order.

    • ofAll

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

    • ofAll

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

    • ofAll

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

    • ofAll

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

    • ofAll

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

    • ofAll

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

    • ofAll

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

    • ofAll

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

    • range

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

      Examples: 

       
 LinkedHashSet.range(0, 0)  // = LinkedHashSet()
 LinkedHashSet.range(2, 0)  // = LinkedHashSet()
 LinkedHashSet.range(-2, 2) // = LinkedHashSet(-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 LinkedHashSet<Character> range(char from, char toExclusive)
      Creates a LinkedHashSet of char numbers starting from from, extending to toExclusive - 1.

      Examples: 

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

    • rangeBy

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

      Examples: 

       
 LinkedHashSet.rangeBy(1, 3, 1)  // = LinkedHashSet(1, 2)
 LinkedHashSet.rangeBy(1, 4, 2)  // = LinkedHashSet(1, 3)
 LinkedHashSet.rangeBy(4, 1, -2) // = LinkedHashSet(4, 2)
 LinkedHashSet.rangeBy(4, 1, 2)  // = LinkedHashSet()
      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 LinkedHashSet<Character> rangeBy(char from, char toExclusive, int step)
      Creates a LinkedHashSet of char numbers starting from from, extending to toExclusive - 1, with step.

      Examples: 

       
 LinkedHashSet.rangeBy('a', 'c', 1)  // = LinkedHashSet('a', 'b')
 LinkedHashSet.rangeBy('a', 'd', 2)  // = LinkedHashSet('a', 'c')
 LinkedHashSet.rangeBy('d', 'a', -2) // = LinkedHashSet('d', 'b')
 LinkedHashSet.rangeBy('d', 'a', 2)  // = LinkedHashSet()
      Parameters:
      from - the first number
      toExclusive - the last number + 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 LinkedHashSet<Double> rangeBy(double from, double toExclusive, double step)
      Creates a LinkedHashSet of double numbers starting from from, extending to toExclusive - 1, with step.

      Examples: 

       
 LinkedHashSet.rangeBy(1.0, 3.0, 1.0)  // = LinkedHashSet(1.0, 2.0)
 LinkedHashSet.rangeBy(1.0, 4.0, 2.0)  // = LinkedHashSet(1.0, 3.0)
 LinkedHashSet.rangeBy(4.0, 1.0, -2.0) // = LinkedHashSet(4.0, 2.0)
 LinkedHashSet.rangeBy(4.0, 1.0, 2.0)  // = LinkedHashSet()
      Parameters:
      from - the first number
      toExclusive - the last number + 1
      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 LinkedHashSet<Long> range(long from, long toExclusive)
      Creates a LinkedHashSet of long numbers starting from from, extending to toExclusive - 1.

      Examples: 

       
 LinkedHashSet.range(0L, 0L)  // = LinkedHashSet()
 LinkedHashSet.range(2L, 0L)  // = LinkedHashSet()
 LinkedHashSet.range(-2L, 2L) // = LinkedHashSet(-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 LinkedHashSet<Long> rangeBy(long from, long toExclusive, long step)
      Creates a LinkedHashSet of long numbers starting from from, extending to toExclusive - 1, with step.

      Examples: 

       
 LinkedHashSet.rangeBy(1L, 3L, 1L)  // = LinkedHashSet(1L, 2L)
 LinkedHashSet.rangeBy(1L, 4L, 2L)  // = LinkedHashSet(1L, 3L)
 LinkedHashSet.rangeBy(4L, 1L, -2L) // = LinkedHashSet(4L, 2L)
 LinkedHashSet.rangeBy(4L, 1L, 2L)  // = LinkedHashSet()
      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 LinkedHashSet<Integer> rangeClosed(int from, int toInclusive)
      Creates a LinkedHashSet of int numbers starting from from, extending to toInclusive.

      Examples: 

       
 LinkedHashSet.rangeClosed(0, 0)  // = LinkedHashSet(0)
 LinkedHashSet.rangeClosed(2, 0)  // = LinkedHashSet()
 LinkedHashSet.rangeClosed(-2, 2) // = LinkedHashSet(-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 LinkedHashSet<Character> rangeClosed(char from, char toInclusive)
      Creates a LinkedHashSet of char numbers starting from from, extending to toInclusive.

      Examples: 

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

    • rangeClosedBy

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

      Examples: 

       
 LinkedHashSet.rangeClosedBy(1, 3, 1)  // = LinkedHashSet(1, 2, 3)
 LinkedHashSet.rangeClosedBy(1, 4, 2)  // = LinkedHashSet(1, 3)
 LinkedHashSet.rangeClosedBy(4, 1, -2) // = LinkedHashSet(4, 2)
 LinkedHashSet.rangeClosedBy(4, 1, 2)  // = LinkedHashSet()
      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 LinkedHashSet<Character> rangeClosedBy(char from, char toInclusive, int step)
      Creates a LinkedHashSet of char numbers starting from from, extending to toInclusive, with step.

      Examples: 

       
 LinkedHashSet.rangeClosedBy('a', 'c', 1)  // = LinkedHashSet('a', 'b', 'c')
 LinkedHashSet.rangeClosedBy('a', 'd', 2)  // = LinkedHashSet('a', 'c')
 LinkedHashSet.rangeClosedBy('d', 'a', -2) // = LinkedHashSet('d', 'b')
 LinkedHashSet.rangeClosedBy('d', 'a', 2)  // = LinkedHashSet()
      Parameters:
      from - the first number
      toInclusive - the last number
      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 LinkedHashSet<Double> rangeClosedBy(double from, double toInclusive, double step)
      Creates a LinkedHashSet of double numbers starting from from, extending to toInclusive, with step.

      Examples: 

       
 LinkedHashSet.rangeClosedBy(1.0, 3.0, 1.0)  // = LinkedHashSet(1.0, 2.0, 3.0)
 LinkedHashSet.rangeClosedBy(1.0, 4.0, 2.0)  // = LinkedHashSet(1.0, 3.0)
 LinkedHashSet.rangeClosedBy(4.0, 1.0, -2.0) // = LinkedHashSet(4.0, 2.0)
 LinkedHashSet.rangeClosedBy(4.0, 1.0, 2.0)  // = LinkedHashSet()
      Parameters:
      from - the first number
      toInclusive - the last number
      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 LinkedHashSet<Long> rangeClosed(long from, long toInclusive)
      Creates a LinkedHashSet of long numbers starting from from, extending to toInclusive.

      Examples: 

       
 LinkedHashSet.rangeClosed(0L, 0L)  // = LinkedHashSet(0L)
 LinkedHashSet.rangeClosed(2L, 0L)  // = LinkedHashSet()
 LinkedHashSet.rangeClosed(-2L, 2L) // = LinkedHashSet(-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 LinkedHashSet<Long> rangeClosedBy(long from, long toInclusive, long step)
      Creates a LinkedHashSet of long numbers starting from from, extending to toInclusive, with step.

      Examples: 

       
 LinkedHashSet.rangeClosedBy(1L, 3L, 1L)  // = LinkedHashSet(1L, 2L, 3L)
 LinkedHashSet.rangeClosedBy(1L, 4L, 2L)  // = LinkedHashSet(1L, 3L)
 LinkedHashSet.rangeClosedBy(4L, 1L, -2L) // = LinkedHashSet(4L, 2L)
 LinkedHashSet.rangeClosedBy(4L, 1L, 2L)  // = LinkedHashSet()
      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 LinkedHashSet<T> add(T element)
      Add the given element to this set, replacing existing one if it is already contained.

      Note that this method has a worst-case linear complexity.

      Specified by:
      add in interface Set<T>
      Parameters:
      element - The element to be added.
      Returns:
      A new set containing all elements of this set and also element.

    • addAll

      public LinkedHashSet<T> addAll(@NonNull Iterable<? extends T> elements)
      Adds all of the given elements to this set, replacing existing one if they are not already contained.

      Note that this method has a worst-case quadratic complexity.

      Specified by:
      addAll in interface Set<T>
      Parameters:
      elements - The elements to be added.
      Returns:
      A new set containing all elements of this set and the given elements, if not already contained.

    • collect

      public <R> LinkedHashSet<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 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

    • 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.

    • diff

      public LinkedHashSet<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>
      Parameters:
      elements - the set of elements to remove
      Returns:
      a new set without the specified elements

    • distinct

      public LinkedHashSet<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 Traversable<T>
      Returns:
      a new Traversable without duplicate elements

    • distinctBy

      public LinkedHashSet<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 Traversable<T>
      Parameters:
      comparator - a comparator used to determine equality of elements
      Returns:
      a new Traversable with duplicates removed

    • distinctBy

      public <U> LinkedHashSet<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 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 LinkedHashSet<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 Traversable<T>
      Parameters:
      n - the number of elements to drop
      Returns:
      a new instance excluding the first n elements

    • dropRight

      public LinkedHashSet<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 Traversable<T>
      Parameters:
      n - the number of elements to drop from the end
      Returns:
      a new instance excluding the last n elements

    • dropUntil

      public LinkedHashSet<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 Traversable<T>
      Parameters:
      predicate - a condition tested on each element
      Returns:
      a new instance starting from the first element matching the predicate

    • dropWhile

      public LinkedHashSet<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 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 LinkedHashSet<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 Traversable<T>
      Parameters:
      predicate - the condition to test elements
      Returns:
      a traversable with elements matching the predicate

    • reject

      public LinkedHashSet<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 Traversable<T>
      Parameters:
      predicate - the condition to test elements
      Returns:
      a traversable with elements not matching the predicate

    • flatMap

      public <U> LinkedHashSet<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 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,LinkedHashSet<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 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<LinkedHashSet<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 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 LinkedHashSet<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 Traversable<T>
      Returns:
      a new instance containing all elements except the last

    • initOption

      public Option<LinkedHashSet<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 Traversable<T>
      Returns:
      Some(traversable) if non-empty, or None if this Traversable is empty

    • intersect

      public LinkedHashSet<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>
      Parameters:
      elements - the set to intersect with
      Returns:
      a new set with elements common to both sets

    • isAsync

      public boolean isAsync()
      An LinkedHashSet's value 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()
      An LinkedHashSet's value 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

    • isSequential

      public boolean isSequential()
      Description copied from interface: Traversable
      Indicates whether the elements of this Traversable appear in encounter (insertion) order.
      Specified by:
      isSequential in interface Traversable<T>
      Returns:
      true if insertion order is preserved, 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> LinkedHashSet<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 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> LinkedHashSet<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 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 LinkedHashSet<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 Traversable<T>
      Specified by:
      mapToVoid in interface Value<T>
      Returns:
      A new value of type Void

    • mkString

      public String mkString(CharSequence prefix, CharSequence delimiter, CharSequence suffix)
      Description copied from interface: Traversable
      Concatenates the string representations of all elements in this Traversable with a prefix, delimiter, and suffix.

      Example: List.of("a", "b", "c").mkString("Chars(", ", ", ")") = "Chars(a, b, c)"

      Specified by:
      mkString in interface Traversable<T>
      Parameters:
      prefix - a string prepended to the result
      delimiter - a string placed between elements
      suffix - a string appended to the result
      Returns:
      a new String containing the formatted concatenation of elements

    • orElse

      public LinkedHashSet<T> orElse(@NonNull Iterable<? extends T> other)
      Description copied from interface: Traversable
      Returns this Traversable if it is non-empty; otherwise, returns the given alternative.
      Specified by:
      orElse in interface Set<T>
      Specified by:
      orElse in interface Traversable<T>
      Parameters:
      other - an alternative Traversable to return if this is empty
      Returns:
      this Traversable if non-empty, otherwise other

    • orElse

      public LinkedHashSet<T> orElse(@NonNull Supplier<? extends Iterable<? extends T>> supplier)
      Description copied from interface: Traversable
      Returns this Traversable if it is non-empty; otherwise, returns the result of evaluating the given supplier.
      Specified by:
      orElse in interface Set<T>
      Specified by:
      orElse in interface Traversable<T>
      Parameters:
      supplier - a supplier of an alternative Traversable if this is empty
      Returns:
      this Traversable if non-empty, otherwise the result of supplier.get()

    • partition

      public Tuple2<LinkedHashSet<T>,LinkedHashSet<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 Traversable<T>
      Parameters:
      predicate - a predicate used to classify elements
      Returns:
      a Tuple2 containing the two resulting Traversable instances

    • peek

      public LinkedHashSet<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 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 LinkedHashSet<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>
      Parameters:
      element - the element to remove
      Returns:
      a new set without the specified element

    • removeAll

      public LinkedHashSet<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>
      Parameters:
      elements - the elements to remove
      Returns:
      a new set without the specified elements

    • replace

      public LinkedHashSet<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 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 LinkedHashSet<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 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 LinkedHashSet<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 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 LinkedHashSet<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 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> LinkedHashSet<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 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> LinkedHashSet<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 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<LinkedHashSet<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 Traversable<T>
      Parameters:
      classifier - A function classifying elements into groups
      Returns:
      An Iterator of windows (grouped elements)

    • sliding

      public Iterator<LinkedHashSet<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 Traversable<T>
      Parameters:
      size - a positive window size
      Returns:
      An Iterator of windows, each containing up to size elements

    • sliding

      public Iterator<LinkedHashSet<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 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<LinkedHashSet<T>,LinkedHashSet<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 Traversable<T>
      Parameters:
      predicate - a predicate used to determine the prefix
      Returns:
      a Tuple containing the prefix and remainder

    • tail

      public LinkedHashSet<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 Traversable<T>
      Returns:
      a new Traversable containing all elements except the first

    • tailOption

      public Option<LinkedHashSet<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 Traversable<T>
      Returns:
      Some(traversable) if non-empty, otherwise None

    • take

      public LinkedHashSet<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 Traversable<T>
      Parameters:
      n - the number of elements to take
      Returns:
      a new Traversable containing the first n elements

    • takeRight

      public LinkedHashSet<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 Traversable<T>
      Parameters:
      n - the number of elements to take from the end
      Returns:
      a new Traversable containing the last n elements

    • takeUntil

      public LinkedHashSet<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 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 LinkedHashSet<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 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(@NonNull Function<? super LinkedHashSet<T>,? extends U> f)
      Transforms this LinkedHashSet.
      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 LinkedHashSet<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 Value<T>
      Returns:
      a new java.util.Set instance

    • union

      public LinkedHashSet<T> union(@NonNull Set<? extends T> elements)
      Adds all of the elements of elements to this set, replacing existing ones if they already present.

      Note that this method has a worst-case quadratic complexity.

      See also addAll(Iterable).

      Specified by:
      union in interface Set<T>
      Parameters:
      elements - The set to form the union with.
      Returns:
      A new set that contains all distinct elements of this and elements set.

    • unzip

      public <T1, T2> Tuple2<LinkedHashSet<T1>,LinkedHashSet<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 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<LinkedHashSet<T1>,LinkedHashSet<T2>,LinkedHashSet<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 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> LinkedHashSet<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 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> LinkedHashSet<R> zipWith(@NonNull Iterable<? extends U> that, @NonNull 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 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> LinkedHashSet<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 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 LinkedHashSet<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 Traversable<T>
      Returns:
      a new Traversable containing each element paired with its index

    • zipWithIndex

      public <U> LinkedHashSet<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 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

    • addAll

      private static <T> LinkedHashMap<T,Object> addAll(LinkedHashMap<T,Object> initial, Iterable<? extends T> additional)

    • writeReplace

      @GwtIncompatible("The Java serialization protocol is explicitly not supported") private Object writeReplace()
      writeReplace method for the serialization proxy pattern.

      The presence of this method causes the serialization system to emit a SerializationProxy instance instead of an instance of the enclosing class.

      Returns:
      A SerializationProxy for this enclosing class.

    • readObject

      @GwtIncompatible("The Java serialization protocol is explicitly not supported") private void readObject(ObjectInputStream stream) throws InvalidObjectException
      readObject method for the serialization proxy pattern.

      Guarantees that the serialization system will never generate a serialized instance of the enclosing class.

      Parameters:
      stream - An object serialization stream.
      Throws:
      InvalidObjectException - This method will throw with the message "Proxy required".