Modul speiger.src.collections
Package speiger.src.collections.objects.maps.interfaces

Klasse Object2ObjectMap.MapBuilder

java.lang.Object
speiger.src.collections.objects.maps.interfaces.Object2ObjectMap.MapBuilder
Umschließende Schnittstelle:
Object2ObjectMap<T,V>
public static final class Object2ObjectMap.MapBuilder extends Object
Helper class that reduces the method spam of the Map Class.

  • Konstruktordetails

    • MapBuilder

      public MapBuilder()

  • Methodendetails

    • start

      public <T, V> Object2ObjectMap.BuilderCache<T,V> start()
      Starts a Map Builder that allows you to create maps as Constants a lot easier Keys and Values are stored as Array and then inserted using the putAllMethod when the mapType is choosen
      Typparameter:
      T - the keyType of elements maintained by this Collection
      V - the keyType of elements maintained by this Collection
      Gibt zurück:
      a MapBuilder

    • start

      public <T, V> Object2ObjectMap.BuilderCache<T,V> start(int size)
      Starts a Map Builder that allows you to create maps as Constants a lot easier Keys and Values are stored as Array and then inserted using the putAllMethod when the mapType is choosen
      Typparameter:
      T - the keyType of elements maintained by this Collection
      V - the keyType of elements maintained by this Collection
      Parameter:
      size - the expected minimum size of Elements in the Map, default is 16
      Gibt zurück:
      a MapBuilder

    • put

      public <T, V> Object2ObjectMap.BuilderCache<T,V> put(T key, V value)
      Starts a Map builder and puts in the Key and Value into it Keys and Values are stored as Array and then inserted using the putAllMethod when the mapType is choosen
      Typparameter:
      T - the keyType of elements maintained by this Collection
      V - the keyType of elements maintained by this Collection
      Parameter:
      key - the key that should be added
      value - the value that should be added
      Gibt zurück:
      a MapBuilder with the key and value stored in it.

    • map

      public <T, V> Object2ObjectOpenHashMap<T,V> map()
      Helper function to unify code
      Typparameter:
      T - the keyType of elements maintained by this Collection
      V - the keyType of elements maintained by this Collection
      Gibt zurück:
      a OpenHashMap

    • map

      public <T, V> Object2ObjectOpenHashMap<T,V> map(int size)
      Helper function to unify code
      Typparameter:
      T - the keyType of elements maintained by this Collection
      V - the keyType of elements maintained by this Collection
      Parameter:
      size - the minimum capacity of the Map
      Gibt zurück:
      a OpenHashMap with a mimimum capacity

    • map

      public <T, V> Object2ObjectOpenHashMap<T,V> map(T[] keys, V[] values)
      Helper function to unify code
      Typparameter:
      T - the keyType of elements maintained by this Collection
      V - the keyType of elements maintained by this Collection
      Parameter:
      keys - the keys that should be inserted
      values - the values that should be inserted
      Gibt zurück:
      a OpenHashMap thats contains the injected values
      Löst aus:
      IllegalStateException - if the keys and values do not match in length

    • map

      public <T, V> Object2ObjectOpenHashMap<T,V> map(Object2ObjectMap<T,V> map)
      Helper function to unify code
      Typparameter:
      T - the keyType of elements maintained by this Collection
      V - the keyType of elements maintained by this Collection
      Parameter:
      map - that should be cloned
      Gibt zurück:
      a OpenHashMap thats copies the contents of the provided map

    • map

      public <T, V> Object2ObjectOpenHashMap<T,V> map(Map<? extends T,? extends V> map)
      Helper function to unify code
      Typparameter:
      T - the keyType of elements maintained by this Collection
      V - the keyType of elements maintained by this Collection
      Parameter:
      map - that should be cloned
      Gibt zurück:
      a OpenHashMap thats copies the contents of the provided map
      Note:
      the map will be unboxed

    • linkedMap

      public <T, V> Object2ObjectLinkedOpenHashMap<T,V> linkedMap()
      Helper function to unify code
      Typparameter:
      T - the keyType of elements maintained by this Collection
      V - the keyType of elements maintained by this Collection
      Gibt zurück:
      a LinkedOpenHashMap

    • linkedMap

      public <T, V> Object2ObjectLinkedOpenHashMap<T,V> linkedMap(int size)
      Helper function to unify code
      Typparameter:
      T - the keyType of elements maintained by this Collection
      V - the keyType of elements maintained by this Collection
      Parameter:
      size - the minimum capacity of the Map
      Gibt zurück:
      a LinkedOpenHashMap with a mimimum capacity

    • linkedMap

      public <T, V> Object2ObjectLinkedOpenHashMap<T,V> linkedMap(T[] keys, V[] values)
      Helper function to unify code
      Typparameter:
      T - the keyType of elements maintained by this Collection
      V - the keyType of elements maintained by this Collection
      Parameter:
      keys - the keys that should be inserted
      values - the values that should be inserted
      Gibt zurück:
      a LinkedOpenHashMap thats contains the injected values
      Löst aus:
      IllegalStateException - if the keys and values do not match in length

    • linkedMap

      public <T, V> Object2ObjectLinkedOpenHashMap<T,V> linkedMap(Object2ObjectMap<T,V> map)
      Helper function to unify code
      Typparameter:
      T - the keyType of elements maintained by this Collection
      V - the keyType of elements maintained by this Collection
      Parameter:
      map - that should be cloned
      Gibt zurück:
      a LinkedOpenHashMap thats copies the contents of the provided map

    • linkedMap

      public <T, V> ImmutableObject2ObjectOpenHashMap<T,V> linkedMap(Map<? extends T,? extends V> map)
      Helper function to unify code
      Typparameter:
      T - the keyType of elements maintained by this Collection
      V - the keyType of elements maintained by this Collection
      Parameter:
      map - that should be cloned
      Gibt zurück:
      a LinkedOpenHashMap thats copies the contents of the provided map
      Note:
      the map will be unboxed

    • immutable

      public <T, V> ImmutableObject2ObjectOpenHashMap<T,V> immutable(T[] keys, V[] values)
      Helper function to unify code
      Typparameter:
      T - the keyType of elements maintained by this Collection
      V - the keyType of elements maintained by this Collection
      Parameter:
      keys - the keys that should be inserted
      values - the values that should be inserted
      Gibt zurück:
      a ImmutableOpenHashMap thats contains the injected values
      Löst aus:
      IllegalStateException - if the keys and values do not match in length

    • immutable

      public <T, V> ImmutableObject2ObjectOpenHashMap<T,V> immutable(Object2ObjectMap<T,V> map)
      Helper function to unify code
      Typparameter:
      T - the keyType of elements maintained by this Collection
      V - the keyType of elements maintained by this Collection
      Parameter:
      map - that should be cloned
      Gibt zurück:
      a ImmutableOpenHashMap thats copies the contents of the provided map

    • immutable

      public <T, V> ImmutableObject2ObjectOpenHashMap<T,V> immutable(Map<? extends T,? extends V> map)
      Helper function to unify code
      Typparameter:
      T - the keyType of elements maintained by this Collection
      V - the keyType of elements maintained by this Collection
      Parameter:
      map - that should be cloned
      Gibt zurück:
      a ImmutableOpenHashMap thats copies the contents of the provided map
      Note:
      the map will be unboxed

    • enumMap

      public <T extends Enum<T>, V> Enum2ObjectMap<T,V> enumMap(Class<T> keyType)
      Helper function to unify code
      Typparameter:
      T - the keyType of elements maintained by this Collection
      V - the keyType of elements maintained by this Collection
      Parameter:
      keyType - the EnumClass that should be used
      Gibt zurück:
      a Empty EnumMap

    • enumMap

      public <T extends Enum<T>, V> Enum2ObjectMap<T,V> enumMap(T[] keys, V[] values)
      Helper function to unify code
      Typparameter:
      T - the keyType of elements maintained by this Collection
      V - the keyType of elements maintained by this Collection
      Parameter:
      keys - the keys that should be inserted
      values - the values that should be inserted
      Gibt zurück:
      a EnumMap thats contains the injected values
      Löst aus:
      IllegalStateException - if the keys and values do not match in length
      IllegalArgumentException - if the keys are in length 0

    • enumMap

      public <T extends Enum<T>, V> Enum2ObjectMap<T,V> enumMap(Map<? extends T,? extends V> map)
      Helper function to unify code
      Typparameter:
      T - the keyType of elements maintained by this Collection
      V - the keyType of elements maintained by this Collection
      Parameter:
      map - that should be cloned
      Gibt zurück:
      a EnumMap thats copies the contents of the provided map
      Löst aus:
      IllegalArgumentException - if the map is Empty and is not a EnumMap
      Note:
      the map will be unboxed

    • enumMap

      public <T extends Enum<T>, V> Enum2ObjectMap<T,V> enumMap(Object2ObjectMap<T,V> map)
      Helper function to unify code
      Typparameter:
      T - the keyType of elements maintained by this Collection
      V - the keyType of elements maintained by this Collection
      Parameter:
      map - that should be cloned
      Gibt zurück:
      a EnumMap thats copies the contents of the provided map
      Löst aus:
      IllegalArgumentException - if the map is Empty and is not a EnumMap

    • linkedEnumMap

      public <T extends Enum<T>, V> LinkedEnum2ObjectMap<T,V> linkedEnumMap(Class<T> keyType)
      Helper function to unify code
      Typparameter:
      T - the keyType of elements maintained by this Collection
      V - the keyType of elements maintained by this Collection
      Parameter:
      keyType - the EnumClass that should be used
      Gibt zurück:
      a Empty LinkedEnumMap

    • linkedEnumMap

      public <T extends Enum<T>, V> LinkedEnum2ObjectMap<T,V> linkedEnumMap(T[] keys, V[] values)
      Helper function to unify code
      Typparameter:
      T - the keyType of elements maintained by this Collection
      V - the keyType of elements maintained by this Collection
      Parameter:
      keys - the keys that should be inserted
      values - the values that should be inserted
      Gibt zurück:
      a LinkedEnumMap thats contains the injected values
      Löst aus:
      IllegalStateException - if the keys and values do not match in length
      IllegalArgumentException - if the keys are in length 0

    • linkedEnumMap

      public <T extends Enum<T>, V> LinkedEnum2ObjectMap<T,V> linkedEnumMap(Map<? extends T,? extends V> map)
      Helper function to unify code
      Typparameter:
      T - the keyType of elements maintained by this Collection
      V - the keyType of elements maintained by this Collection
      Parameter:
      map - that should be cloned
      Gibt zurück:
      a LinkedEnumMap thats copies the contents of the provided map
      Löst aus:
      IllegalArgumentException - if the map is Empty and is not a EnumMap
      Note:
      the map will be unboxed

    • linkedEnumMap

      public <T extends Enum<T>, V> LinkedEnum2ObjectMap<T,V> linkedEnumMap(Object2ObjectMap<T,V> map)
      Helper function to unify code
      Typparameter:
      T - the keyType of elements maintained by this Collection
      V - the keyType of elements maintained by this Collection
      Parameter:
      map - that should be cloned
      Gibt zurück:
      a LinkedEnumMap thats copies the contents of the provided map
      Löst aus:
      IllegalArgumentException - if the map is Empty and is not a EnumMap

    • customMap

      public <T, V> Object2ObjectOpenCustomHashMap<T,V> customMap(ObjectStrategy<T> strategy)
      Helper function to unify code
      Typparameter:
      T - the keyType of elements maintained by this Collection
      V - the keyType of elements maintained by this Collection
      Parameter:
      strategy - the Hash Controller
      Gibt zurück:
      a CustomOpenHashMap

    • customMap

      public <T, V> Object2ObjectOpenCustomHashMap<T,V> customMap(int size, ObjectStrategy<T> strategy)
      Helper function to unify code
      Typparameter:
      T - the keyType of elements maintained by this Collection
      V - the keyType of elements maintained by this Collection
      Parameter:
      size - the minimum capacity of the Map
      strategy - the Hash Controller
      Gibt zurück:
      a CustomOpenHashMap with a mimimum capacity

    • customMap

      public <T, V> Object2ObjectOpenCustomHashMap<T,V> customMap(T[] keys, V[] values, ObjectStrategy<T> strategy)
      Helper function to unify code
      Typparameter:
      T - the keyType of elements maintained by this Collection
      V - the keyType of elements maintained by this Collection
      Parameter:
      keys - the keys that should be inserted
      values - the values that should be inserted
      strategy - the Hash Controller
      Gibt zurück:
      a CustomOpenHashMap thats contains the injected values
      Löst aus:
      IllegalStateException - if the keys and values do not match in length

    • customMap

      public <T, V> Object2ObjectOpenCustomHashMap<T,V> customMap(Object2ObjectMap<T,V> map, ObjectStrategy<T> strategy)
      Helper function to unify code
      Typparameter:
      T - the keyType of elements maintained by this Collection
      V - the keyType of elements maintained by this Collection
      Parameter:
      map - that should be cloned
      strategy - the Hash Controller
      Gibt zurück:
      a CustomOpenHashMap thats copies the contents of the provided map

    • customMap

      public <T, V> Object2ObjectOpenCustomHashMap<T,V> customMap(Map<? extends T,? extends V> map, ObjectStrategy<T> strategy)
      Helper function to unify code
      Typparameter:
      T - the keyType of elements maintained by this Collection
      V - the keyType of elements maintained by this Collection
      Parameter:
      map - that should be cloned
      strategy - the Hash Controller
      Gibt zurück:
      a CustomOpenHashMap thats copies the contents of the provided map
      Note:
      the map will be unboxed

    • customLinkedMap

      public <T, V> Object2ObjectLinkedOpenCustomHashMap<T,V> customLinkedMap(ObjectStrategy<T> strategy)
      Helper function to unify code
      Typparameter:
      T - the keyType of elements maintained by this Collection
      V - the keyType of elements maintained by this Collection
      Parameter:
      strategy - the Hash Controller
      Gibt zurück:
      a CustomLinkedOpenHashMap

    • customLinkedMap

      public <T, V> Object2ObjectLinkedOpenCustomHashMap<T,V> customLinkedMap(int size, ObjectStrategy<T> strategy)
      Helper function to unify code
      Typparameter:
      T - the keyType of elements maintained by this Collection
      V - the keyType of elements maintained by this Collection
      Parameter:
      size - the minimum capacity of the Map
      strategy - the Hash Controller
      Gibt zurück:
      a CustomLinkedOpenHashMap with a mimimum capacity

    • customLinkedMap

      public <T, V> Object2ObjectLinkedOpenCustomHashMap<T,V> customLinkedMap(T[] keys, V[] values, ObjectStrategy<T> strategy)
      Helper function to unify code
      Typparameter:
      T - the keyType of elements maintained by this Collection
      V - the keyType of elements maintained by this Collection
      Parameter:
      keys - the keys that should be inserted
      values - the values that should be inserted
      strategy - the Hash Controller
      Gibt zurück:
      a CustomLinkedOpenHashMap thats contains the injected values
      Löst aus:
      IllegalStateException - if the keys and values do not match in length

    • customLinkedMap

      public <T, V> Object2ObjectLinkedOpenCustomHashMap<T,V> customLinkedMap(Object2ObjectMap<T,V> map, ObjectStrategy<T> strategy)
      Helper function to unify code
      Typparameter:
      T - the keyType of elements maintained by this Collection
      V - the keyType of elements maintained by this Collection
      Parameter:
      map - that should be cloned
      strategy - the Hash Controller
      Gibt zurück:
      a CustomLinkedOpenHashMap thats copies the contents of the provided map

    • customLinkedMap

      public <T, V> Object2ObjectLinkedOpenCustomHashMap<T,V> customLinkedMap(Map<? extends T,? extends V> map, ObjectStrategy<T> strategy)
      Helper function to unify code
      Typparameter:
      T - the keyType of elements maintained by this Collection
      V - the keyType of elements maintained by this Collection
      Parameter:
      map - that should be cloned
      strategy - the Hash Controller
      Gibt zurück:
      a CustomLinkedOpenHashMap thats copies the contents of the provided map
      Note:
      the map will be unboxed

    • arrayMap

      public <T, V> Object2ObjectArrayMap<T,V> arrayMap()
      Helper function to unify code
      Typparameter:
      T - the keyType of elements maintained by this Collection
      V - the keyType of elements maintained by this Collection
      Gibt zurück:
      a OpenHashMap

    • arrayMap

      public <T, V> Object2ObjectArrayMap<T,V> arrayMap(int size)
      Helper function to unify code
      Typparameter:
      T - the keyType of elements maintained by this Collection
      V - the keyType of elements maintained by this Collection
      Parameter:
      size - the minimum capacity of the Map
      Gibt zurück:
      a OpenHashMap with a mimimum capacity

    • arrayMap

      public <T, V> Object2ObjectArrayMap<T,V> arrayMap(T[] keys, V[] values)
      Helper function to unify code
      Typparameter:
      T - the keyType of elements maintained by this Collection
      V - the keyType of elements maintained by this Collection
      Parameter:
      keys - the keys that should be inserted
      values - the values that should be inserted
      Gibt zurück:
      a OpenHashMap thats contains the injected values
      Löst aus:
      IllegalStateException - if the keys and values do not match in length

    • arrayMap

      public <T, V> Object2ObjectArrayMap<T,V> arrayMap(Object2ObjectMap<T,V> map)
      Helper function to unify code
      Typparameter:
      T - the keyType of elements maintained by this Collection
      V - the keyType of elements maintained by this Collection
      Parameter:
      map - that should be cloned
      Gibt zurück:
      a OpenHashMap thats copies the contents of the provided map

    • arrayMap

      public <T, V> Object2ObjectArrayMap<T,V> arrayMap(Map<? extends T,? extends V> map)
      Helper function to unify code
      Typparameter:
      T - the keyType of elements maintained by this Collection
      V - the keyType of elements maintained by this Collection
      Parameter:
      map - that should be cloned
      Gibt zurück:
      a OpenHashMap thats copies the contents of the provided map
      Note:
      the map will be unboxed

    • rbTreeMap

      public <T, V> Object2ObjectRBTreeMap<T,V> rbTreeMap()
      Helper function to unify code
      Typparameter:
      T - the keyType of elements maintained by this Collection
      V - the keyType of elements maintained by this Collection
      Gibt zurück:
      a RBTreeMap

    • rbTreeMap

      public <T, V> Object2ObjectRBTreeMap<T,V> rbTreeMap(Comparator<T> comp)
      Helper function to unify code
      Typparameter:
      T - the keyType of elements maintained by this Collection
      V - the keyType of elements maintained by this Collection
      Parameter:
      comp - the Sorter of the TreeMap
      Gibt zurück:
      a RBTreeMap

    • rbTreeMap

      public <T, V> Object2ObjectRBTreeMap<T,V> rbTreeMap(T[] keys, V[] values, Comparator<T> comp)
      Helper function to unify code
      Typparameter:
      T - the keyType of elements maintained by this Collection
      V - the keyType of elements maintained by this Collection
      Parameter:
      keys - the keys that should be inserted
      values - the values that should be inserted
      comp - the Sorter of the TreeMap
      Gibt zurück:
      a RBTreeMap thats contains the injected values
      Löst aus:
      IllegalStateException - if the keys and values do not match in length

    • rbTreeMap

      public <T, V> Object2ObjectRBTreeMap<T,V> rbTreeMap(Object2ObjectMap<T,V> map, Comparator<T> comp)
      Helper function to unify code
      Typparameter:
      T - the keyType of elements maintained by this Collection
      V - the keyType of elements maintained by this Collection
      Parameter:
      map - that should be cloned
      comp - the Sorter of the TreeMap
      Gibt zurück:
      a RBTreeMap thats copies the contents of the provided map

    • rbTreeMap

      public <T, V> Object2ObjectRBTreeMap<T,V> rbTreeMap(Map<? extends T,? extends V> map, Comparator<T> comp)
      Helper function to unify code
      Typparameter:
      T - the keyType of elements maintained by this Collection
      V - the keyType of elements maintained by this Collection
      Parameter:
      map - that should be cloned
      comp - the Sorter of the TreeMap
      Gibt zurück:
      a RBTreeMap thats copies the contents of the provided map
      Note:
      the map will be unboxed

    • avlTreeMap

      public <T, V> Object2ObjectAVLTreeMap<T,V> avlTreeMap()
      Helper function to unify code
      Typparameter:
      T - the keyType of elements maintained by this Collection
      V - the keyType of elements maintained by this Collection
      Gibt zurück:
      a AVLTreeMap

    • avlTreeMap

      public <T, V> Object2ObjectAVLTreeMap<T,V> avlTreeMap(Comparator<T> comp)
      Helper function to unify code
      Typparameter:
      T - the keyType of elements maintained by this Collection
      V - the keyType of elements maintained by this Collection
      Parameter:
      comp - the Sorter of the TreeMap
      Gibt zurück:
      a AVLTreeMap

    • avlTreeMap

      public <T, V> Object2ObjectAVLTreeMap<T,V> avlTreeMap(T[] keys, V[] values, Comparator<T> comp)
      Helper function to unify code
      Typparameter:
      T - the keyType of elements maintained by this Collection
      V - the keyType of elements maintained by this Collection
      Parameter:
      keys - the keys that should be inserted
      values - the values that should be inserted
      comp - the Sorter of the TreeMap
      Gibt zurück:
      a AVLTreeMap thats contains the injected values
      Löst aus:
      IllegalStateException - if the keys and values do not match in length

    • avlTreeMap

      public <T, V> Object2ObjectAVLTreeMap<T,V> avlTreeMap(Object2ObjectMap<T,V> map, Comparator<T> comp)
      Helper function to unify code
      Typparameter:
      T - the keyType of elements maintained by this Collection
      V - the keyType of elements maintained by this Collection
      Parameter:
      map - that should be cloned
      comp - the Sorter of the TreeMap
      Gibt zurück:
      a AVLTreeMap thats copies the contents of the provided map

    • avlTreeMap

      public <T, V> Object2ObjectAVLTreeMap<T,V> avlTreeMap(Map<? extends T,? extends V> map, Comparator<T> comp)
      Helper function to unify code
      Typparameter:
      T - the keyType of elements maintained by this Collection
      V - the keyType of elements maintained by this Collection
      Parameter:
      map - that should be cloned
      comp - the Sorter of the TreeMap
      Gibt zurück:
      a AVLTreeMap thats copies the contents of the provided map
      Note:
      the map will be unboxed