org.eclipse.net4j.util.collection

## Class MultiMap<K,V>

- java.lang.Object
- - org.eclipse.net4j.util.collection.MultiMap<K,V>

- All Implemented Interfaces:
    Map<K,V>
  Direct Known Subclasses:
    MultiMap.ListBased

      public abstract class MultiMap<K,V>
      extends Object
      implements Map<K,V>

  Author:
    Eike Stepper

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `static class` | `MultiMap.ListBased<K,V>`

    - ### Nested classes/interfaces inherited from interface java.util.Map

      `Map.Entry<K,V>`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `MultiMap()`

  - ### Method Summary

    All Methods Instance Methods Abstract Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `clear()`
    `boolean` | `containsKey(Object key)`
    `protected boolean` | `containsKey(Object key, int delegateCount)`
    `boolean` | `containsValue(Object value)`
    `protected abstract Map<K,V>` | `doGetDelegate(int index)`
    `Set<Map.Entry<K,V>>` | `entrySet()`
    `V` | `get(Object key)`
    `Map<K,V>` | `getDelegate(int index)`
    `abstract int` | `getDelegateCount()`
    `boolean` | `isEmpty()`
    `Set<K>` | `keySet()`
    `V` | `put(K key, V value)`
    `void` | `putAll(Map<? extends K,? extends V> t)`
    `V` | `remove(Object key)`
    `int` | `size()`
    `Collection<V>` | `values()`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

    - ### Methods inherited from interface java.util.Map

      `compute, computeIfAbsent, computeIfPresent, equals, forEach, getOrDefault, hashCode, merge, putIfAbsent, remove, replace, replace, replaceAll`

- - ### Constructor Detail

    - #### MultiMap

          public MultiMap()

  - ### Method Detail

    - #### getDelegateCount

          public abstract int getDelegateCount()

    - #### getDelegate

          public Map<K,V> getDelegate(int index)

    - #### clear

          public void clear()

      Specified by:
        `clear` in interface `Map<K,V>`
      Category
        WRITE

    - #### put

          public V put(K key,
                       V value)

      Specified by:
        `put` in interface `Map<K,V>`
      Category
        WRITE

    - #### putAll

          public void putAll(Map<? extends K,? extends V> t)

      Specified by:
        `putAll` in interface `Map<K,V>`
      Category
        WRITE

    - #### remove

          public V remove(Object key)

      Specified by:
        `remove` in interface `Map<K,V>`
      Category
        WRITE

    - #### containsKey

          public boolean containsKey(Object key)

      Specified by:
        `containsKey` in interface `Map<K,V>`
      Category
        READ

    - #### containsValue

          public boolean containsValue(Object value)

      Specified by:
        `containsValue` in interface `Map<K,V>`
      Category
        READ

    - #### get

          public V get(Object key)

      Specified by:
        `get` in interface `Map<K,V>`
      Category
        READ

    - #### size

          public int size()

      Specified by:
        `size` in interface `Map<K,V>`
      Category
        READ

    - #### isEmpty

          public boolean isEmpty()

      Specified by:
        `isEmpty` in interface `Map<K,V>`
      Category
        READ

    - #### entrySet

          public Set<Map.Entry<K,V>> entrySet()

      Specified by:
        `entrySet` in interface `Map<K,V>`

    - #### keySet

          public Set<K> keySet()

      Specified by:
        `keySet` in interface `Map<K,V>`

    - #### values

          public Collection<V> values()

      Specified by:
        `values` in interface `Map<K,V>`

    - #### containsKey

          protected boolean containsKey(Object key,
                                        int delegateCount)

    - #### doGetDelegate

          protected abstract Map<K,V> doGetDelegate(int index)

Copyright (c) 2014 Eike Stepper (Berlin, Germany) and others.
All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html