Tree.Empty (Vavr 0.10.4 API)

java.lang.Object
- io.vavr.collection.Tree.Empty<T>

Type Parameters:

T - type of the tree's values

All Implemented Interfaces:

Foldable<T>, Traversable<T>, Tree<T>, Value<T>, Serializable, Iterable<T>

Enclosing interface:

Tree<T>
```
public static final class Tree.Empty<T>
extends Object
implements Tree<T>, Serializable
```
The empty tree. Use Tree.empty() to create an instance.

See Also:

Serialized Form

Nested Class Summary
- Nested classes/interfaces inherited from interface io.vavr.collection.Tree
  Tree.Empty<T>, Tree.Node<T>, Tree.Order

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`String`	`draw()` Creates a neat 2-dimensional drawing of a tree.
`boolean`	`equals(Object o)` In Vavr there are four basic classes of collections: Seq (sequential elements) Set (distinct elements) Map (indexed elements) Multimap (indexed collections) Two collection instances of these classes are equal if and only if both collections belong to the same basic collection class (Seq, Set, Map or Multimap) contain the same elements have the same element order, if the collections are of type Seq Two Map/Multimap elements, resp.
`List<Tree.Node<T>>`	`getChildren()` Returns the children of this tree.
`T`	`getValue()` Gets the value of this tree.
`int`	`hashCode()` Returns the hash code of this collection.
`static <T> Tree.Empty<T>`	`instance()`
`boolean`	`isEmpty()` Checks if this Traversable is empty.
`boolean`	`isLeaf()` Checks if this Tree is a leaf.
`T`	`last()` Dual of Traversable.head(), returning the last element.
`int`	`length()` Computes the number of elements of this Traversable.
`String`	`toLispString()` Creates a Lisp-like representation of this `Tree`.
`String`	`toString()` Clarifies that values have a proper toString() method implemented.

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

Methods inherited from interface io.vavr.collection.Tree
branchCount, build, collect, collector, distinct, distinctBy, distinctBy, drop, dropRight, dropUntil, dropWhile, empty, fill, fill, filter, flatMap, foldRight, groupBy, grouped, hasDefiniteSize, head, init, initOption, isAsync, isBranch, isDistinct, isLazy, isSequential, isTraversableAgain, iterator, iterator, leafCount, map, narrow, nodeCount, of, of, of, of, ofAll, ofAll, orElse, orElse, partition, peek, recurse, reject, replace, replaceAll, retainAll, scan, scanLeft, scanRight, slideBy, sliding, sliding, span, stringPrefix, tabulate, tail, tailOption, take, takeRight, takeUntil, takeWhile, transform, traverse, traverse, unzip, unzip3, values, values, zip, zipAll, zipWith, zipWithIndex, zipWithIndex

Methods inherited from interface io.vavr.collection.Traversable
arrangeBy, average, containsAll, count, existsUnique, find, findLast, foldLeft, forEachWithIndex, get, headOption, isOrdered, isSingleValued, lastOption, max, maxBy, maxBy, min, minBy, minBy, mkCharSeq, mkCharSeq, mkCharSeq, mkString, mkString, mkString, narrow, nonEmpty, product, reduceLeft, reduceLeftOption, reduceRight, reduceRightOption, single, singleOption, size, spliterator, sum

Methods inherited from interface io.vavr.collection.Foldable
fold, reduce, reduceOption

Methods inherited from interface io.vavr.Value
collect, collect, contains, corresponds, eq, exists, forAll, forEach, getOrElse, getOrElse, getOrElseThrow, getOrElseTry, getOrNull, narrow, out, out, stderr, stdout, toArray, toCharSeq, toCompletableFuture, toEither, toEither, toInvalid, toInvalid, toJavaArray, toJavaArray, toJavaArray, toJavaCollection, toJavaList, toJavaList, toJavaMap, toJavaMap, toJavaMap, toJavaOptional, toJavaParallelStream, toJavaSet, toJavaSet, toJavaStream, toLeft, toLeft, toLinkedMap, toLinkedMap, toLinkedSet, toList, toMap, toMap, toOption, toPriorityQueue, toPriorityQueue, toQueue, toRight, toRight, toSet, toSortedMap, toSortedMap, toSortedMap, toSortedMap, toSortedSet, toSortedSet, toStream, toTree, toTree, toTry, toTry, toValid, toValid, toValidation, toValidation, toVector

- Method Detail
  - instance
```
public static <T> Tree.Empty<T> instance()
```
  - getChildren
```
public List<Tree.Node<T>> getChildren()
```
    Description copied from interface: Tree
    
    Returns the children of this tree.
    
    Specified by:
    
    getChildren in interface Tree<T>
    
    Returns:
    
    the tree's children
  - getValue
```
public T getValue()
```
    Description copied from interface: Tree
    
    Gets the value of this tree.
    
    Specified by:
    
    getValue in interface Tree<T>
    
    Returns:
    
    The value of this tree.
  - isEmpty
```
public boolean isEmpty()
```
    Description copied from interface: Traversable
    
    Checks if this Traversable is empty.
    
    Specified by:
    
    isEmpty in interface Traversable<T>
    
    Specified by:
    
    isEmpty in interface Value<T>
    
    Returns:
    
    true, if this Traversable contains no elements, false otherwise.
  - length
```
public int length()
```
    Description copied from interface: Traversable
    
    Computes the number of elements of this Traversable.
    Same as Traversable.size().
    
    Specified by:
    
    length in interface Traversable<T>
    
    Returns:
    
    the number of elements
  - isLeaf
```
public boolean isLeaf()
```
    Description copied from interface: Tree
    
    Checks if this Tree is a leaf. A tree is a leaf if it is a Node with no children. Because the empty tree is no Node, it is not a leaf by definition.
    
    Specified by:
    
    isLeaf in interface Tree<T>
    
    Returns:
    
    true if this tree is a leaf, false otherwise.
  - last
```
public T last()
```
    Description copied from interface: Traversable
    
    Dual of Traversable.head(), returning the last element.
    
    Specified by:
    
    last in interface Traversable<T>
    
    Returns:
    
    the last element.
  - equals
```
public boolean equals(Object o)
```
    Description copied from interface: Traversable
    In Vavr there are four basic classes of collections:
    - Seq (sequential elements)
    - Set (distinct elements)
    - Map (indexed elements)
    - Multimap (indexed collections)
    Two collection instances of these classes are equal if and only if both collections
    - belong to the same basic collection class (Seq, Set, Map or Multimap)
    - contain the same elements
    - have the same element order, if the collections are of type Seq
    Two Map/Multimap elements, resp. entries, (key1, value1) and (key2, value2) are equal, if the keys are equal and the values are equal.
    Notes:
    - No collection instance equals null, e.g. Queue(1) not equals null.
    - Nulls are allowed and handled as expected, e.g. List(null, 1) equals Stream(null, 1) and HashMap((null, 1)) equals LinkedHashMap((null, 1)).
    - The element order is taken into account for Seq only. E.g. List(null, 1) not equals Stream(1, null) and HashMap((null, 1), ("a", null)) equals LinkedHashMap(("a", null), (null, 1)). The reason is, that we do not know which implementations we compare when having two instances of type Map, Multimap or Set (see Liskov Substitution Principle).
    - Other collection classes are equal if their types are equal and their elements are equal (in iteration order).
    - Iterator equality is defined to be object reference equality.
    Specified by:
    
    equals in interface Traversable<T>
    
    Specified by:
    
    equals in interface Tree<T>
    
    Specified by:
    
    equals in interface Value<T>
    
    Overrides:
    
    equals in class Object
    
    Parameters:
    
    o - an object, may be null
    
    Returns:
    
    true, if this collection equals the given object according to the rules described above, false otherwise.
  - hashCode
```
public int hashCode()
```
    Description copied from interface: Traversable
    Returns the hash code of this collection.
    We distinguish between two types of hashes, those for collections with predictable iteration order (like Seq) and those with arbitrary iteration order (like Set, Map and Multimap).
    In all cases the hash of an empty collection is defined to be 1.
    Collections with predictable iteration order are hashed as follows:
```
 int hash = 1;
 for (T t : this) { hash = hash * 31 + Objects.hashCode(t); }
 
```
    Collections with arbitrary iteration order are hashed in a way such that the hash of a fixed number of elements is independent of their iteration order.
```
 int hash = 1;
 for (T t : this) { hash += Objects.hashCode(t); }
 
```
    Please note that the particular hashing algorithms may change in a future version of Vavr.
    Generally, hash codes of collections aren't cached in Vavr (opposed to the size/length). Storing hash codes in order to reduce the time complexity would increase the memory footprint. Persistent collections are built upon tree structures, it allows us to implement efficient memory sharing. A drawback of tree structures is that they make it necessary to store collection attributes at each tree node (read: element).
    The computation of the hash code is linear in time, i.e. O(n). If the hash code of a collection is re-calculated often, e.g. when using a List as HashMap key, we might want to cache the hash code. This can be achieved by simply using a wrapper class, which is not included in Vavr but could be implemented like this:
```
 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;
     }

     &#64;Override
     public boolean equals(Object o) {
         if (o == key) {
             return true;
         } else if (key != null && o instanceof Hashed) {
             final Hashed that = (Hashed) o;
             return key.equals(that.key);
         } else {
             return false;
         }
     }

     &#64;Override
     public int hashCode() {
         return hashCode.get();
     }

     &#64;Override
     public String toString() {
         return "Hashed(" + (key == null ? "null" : key.toString()) + ")";
     }
 }
```
    Specified by:
    
    hashCode in interface Traversable<T>
    
    Specified by:
    
    hashCode in interface Tree<T>
    
    Specified by:
    
    hashCode in interface Value<T>
    
    Overrides:
    
    hashCode in class Object
    
    Returns:
    
    The hash code of this collection
  - 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 Tree<T>
    
    Specified by:
    
    toString in interface Value<T>
    
    Overrides:
    
    toString in class Object
    
    Returns:
    
    A String representation of this object
  - toLispString
```
public String toLispString()
```
    Description copied from interface: Tree
    
    Creates a Lisp-like representation of this Tree.
    
    Specified by:
    
    toLispString in interface Tree<T>
    
    Returns:
    
    This Tree as Lisp-string, i.e. represented as list of lists.
  - draw
```
public String draw()
```
    Description copied from interface: Tree
    
    Creates a neat 2-dimensional drawing of a tree. Unicode characters are used to draw node junctions.
    
    Specified by:
    
    draw in interface Tree<T>
    
    Returns:
    
    A nice string representation of the tree.

Class Tree.Empty<T>

Nested Class Summary

Nested classes/interfaces inherited from interface io.vavr.collection.Tree

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface io.vavr.collection.Tree

Methods inherited from interface io.vavr.collection.Traversable

Methods inherited from interface io.vavr.collection.Foldable

Methods inherited from interface io.vavr.Value

Method Detail

instance

getChildren

getValue

isEmpty

length

isLeaf

last

equals

hashCode

toString

toLispString

draw