Class Key1List<E,​K>

  • Type Parameters:
    E - type of elements stored in the list
    K - type of key
    All Implemented Interfaces:
    java.io.Serializable, java.lang.Cloneable, java.lang.Iterable<E>, java.util.Collection<E>, java.util.List<E>, java.util.RandomAccess, ICollection<E>, IListable<E>
    Direct Known Subclasses:
    Key1List.ReadOnlyKey1List

    public class Key1List<E,​K>
    extends KeyListImpl<E>
    Key1List implements a key list with 1 key. This key can be accessed fast. It can provide fast access to its elements like a Set. The elements allowed in the list can be constraint (null/duplicate values).
    See Also:
    Serialized Form
    • Constructor Detail

      • Key1List

        protected Key1List()
        Protected constructor used by builder or derived collections.
      • Key1List

        protected Key1List​(boolean copy,
                           Key1List<E,​K> that)
    • Method Detail

      • getBuilder

        protected Key1List.Builder<E,​K> getBuilder()
        Returns:
        builder to use in extending classes
      • copy

        public Key1List<E,​K> copy()
        Description copied from class: IList
        Returns a shallow copy of this list. The new list will contain the same elements as the source list, i.e. the elements themselves are not copied. The capacity of the list will be set to the number of elements, i.e. size and capacity are equal. This returned list will be modifiable, i.e. a read-only list will be copied and be modifiable again.
        Specified by:
        copy in interface ICollection<E>
        Specified by:
        copy in class IList<E>
        Returns:
        a modifiable copy of this list
      • clone

        public Key1List<E,​K> clone()
        Description copied from class: IList
        Returns a shallow copy of this list. The new list will contain the same elements as the source list, i.e. the elements themselves are not copied. The capacity of the list will be set to the number of elements, i.e. size and capacity are equal. If the list is read-only, the same list is returned without change. Use IList.copy() to .
        Overrides:
        clone in class KeyListImpl<E>
        Returns:
        a modifiable copy of this list
      • crop

        public Key1List<E,​K> crop()
        Description copied from class: KeyListImpl
        Returns a copy this list but without elements. The new list will have the same type as this list and use the same comparator, ordering, etc.
        Specified by:
        crop in interface ICollection<E>
        Overrides:
        crop in class KeyListImpl<E>
        Returns:
        an empty copy of this list
      • getAll

        public IList<E> getAll​(E elem)
        Description copied from class: IList
        Returns all elements in the list equal to the specified element.
        Overrides:
        getAll in class KeyListImpl<E>
        Parameters:
        elem - element to look for
        Returns:
        all elements in the list equal to the specified element
      • count

        public int count​(E elem)
        Description copied from class: IList
        Counts how many times the specified element is contained in the list.
        Overrides:
        count in class KeyListImpl<E>
        Parameters:
        elem - element to count
        Returns:
        count how many times the specified element is contained in the list
      • removeAll

        public IList<E> removeAll​(E elem)
        Description copied from class: IList
        Removes all equal elements.
        Overrides:
        removeAll in class KeyListImpl<E>
        Parameters:
        elem - element
        Returns:
        removed equal elements (never null)
      • getDistinct

        public java.util.Set<E> getDistinct()
        Description copied from class: IList
        Returns distinct elements in the list.
        Overrides:
        getDistinct in class KeyListImpl<E>
        Returns:
        distinct elements in the list
      • put

        public E put​(E elem)
        Description copied from class: KeyListImpl
        Adds or replaces element. If there is no such element, the element is added. If there is such an element, the element is replaced. So said simply, it is a shortcut for the following code:
         if (contains(elem)) {
           remove(elem);
         }
         add(elem);
         
        However the method is atomic in the sense that all or none operations are executed. So if there is already such an element, but adding the new one fails due to a constraint violation, the old element remains in the list.
        Overrides:
        put in class KeyListImpl<E>
        Parameters:
        elem - element
        Returns:
        element which has been replaced or null otherwise
      • getKey1Mapper

        public java.util.function.Function<E,​K> getKey1Mapper()
        Returns mapper for key map.
        Returns:
        mapper for key map
      • asMap1

        public java.util.Map<K,​E> asMap1()
        Returns a map view to the key map. The collection can be modified through the map as long as the constraint are not violated. Note however that operations put() and remove() will be slow if the list is not sorted by the key and the element must therefore be searched. The collections returned by the methods entrySet(), keySet(), and values() are immutable however.
        Returns:
        map view to key map
        Throws:
        java.lang.IllegalArgumentException - if the key map cannot be viewed as Map
      • indexOfKey1

        public int indexOfKey1​(K key)
        Returns index of first element in list with specified key.
        Parameters:
        key - key
        Returns:
        index of first element, -1 if no such element exists
      • containsKey1

        public boolean containsKey1​(K key)
        Checks whether an element with specified key exists.
        Parameters:
        key - key
        Returns:
        true if element with specified key exists, otherwise false
      • getByKey1

        public E getByKey1​(K key)
        Returns element with specified key. If there are several elements with the same key, the one added first will be returned.
        Parameters:
        key - key
        Returns:
        element with specified key or null
      • getAllByKey1

        public IList<E> getAllByKey1​(K key)
        Returns all elements with specified key.
        Parameters:
        key - key
        Returns:
        all elements with specified key (never null)
      • getCountByKey1

        public int getCountByKey1​(K key)
        Returns the number of elements with specified key.
        Parameters:
        key - key
        Returns:
        number of elements with specified key
      • removeByKey1

        public E removeByKey1​(K key)
        Removes element with specified key. If there are several elements with the same key, the one added first will be removed.
        Parameters:
        key - key
        Returns:
        element with specified key or null
      • removeAllByKey1

        public IList<E> removeAllByKey1​(K key)
        Removes all elements with specified key.
        Parameters:
        key - key
        Returns:
        removed elements with specified key (never null)
      • getAllKeys1

        public IList<K> getAllKeys1()
        Returns list containing all keys in element order.
        Returns:
        list containing all keys
      • getDistinctKeys1

        public java.util.Set<K> getDistinctKeys1()
        Returns all distinct keys in the same order as in the key map.
        Returns:
        distinct keys
      • putByKey1

        public E putByKey1​(E elem)
        Adds element by key. If there is no such element, the element is added. If there is such an element, the element is replaced. So said simply, it is a shortcut for the following code:
         removeByKey1(elem.getKey1());
         add(elem);
         
        However the method is atomic in the sense that all or none operations are executed. So if there is already such an element, but adding the new one fails due to a constraint violation, the old element remains in the list.
        Parameters:
        elem - element
        Returns:
        element with the same key which has been replaced or null otherwise
      • putIfAbsentByKey1

        public E putIfAbsentByKey1​(E elem)
        Adds or replaces element by key. If there is no such element, the element is added. If there is such an element, the element is left unchanged. So said simply, it is a shortcut for the following code:
         if (!containsKey1(elem.getKey1())) {
           add(elem);
         }
         
        However the method is atomic in the sense that all or none operations are executed. So if there is already such an element, but adding the new one fails due to a constraint violation, the old element remains in the list.
        Parameters:
        elem - element
        Returns:
        element with the same key which has been left unchanged or null otherwise
      • invalidateKey1

        public void invalidateKey1​(K oldKey,
                                   K newKey,
                                   E elem)
        Invalidate key value of element. You must call an invalidate method if an element's key value has changed after adding it to the collection.
        Parameters:
        oldKey - old key value
        newKey - new key value
        elem - element to invalidate (can be null if there are no duplicates with this key)
      • isReadOnly

        public boolean isReadOnly()
        Description copied from class: IList
        Returns true if this list is either unmodifiable or immutable, false otherwise.
        Specified by:
        isReadOnly in class IList<E>
      • unmodifiableList

        public Key1List<E,​K> unmodifiableList()
        Description copied from class: IList
        Returns an unmodifiable view of this list. This method allows modules to provide users with "read-only" access to internal lists, where changes made to the original list are visible as query operations on the returned list "read through" to the specified list. Attempts to modify the returned list, whether direct or via its iterator, result in an UnsupportedOperationException. If this list is already unmodifiable, it is returned unchanged. See IList.immutableList() to get an immutable copy of a list.
        Specified by:
        unmodifiableList in class IList<E>
        Returns:
        an unmodifiable view of the specified list
      • immutableList

        public Key1List<E,​K> immutableList()
        Description copied from class: IList
        Returns an immutable copy of this list. The returned list is independent from the original list, i.e. changes done later are not seen. Attempts to modify the returned list, whether direct or via its iterator, result in an UnsupportedOperationException. If this list is already immutable, it is returned unchanged. See IList.unmodifiableList() to get unmodifiable view of a list.
        Specified by:
        immutableList in class IList<E>
        Returns:
        an immutable copy of the specified list