【用法示例】

        在 Android Framework 源码中经常可以看到使用 DefaultKeyedVector 类型的容器。举个例子，在 AudioPolicyManagerBase.cpp 中我们可以看到如下代码：

SortedVector<audio_io_handle_t> AudioPolicyManagerBase::getOutputsForDevice(audio_devices_t device,
                        DefaultKeyedVector<audio_io_handle_t, AudioOutputDescriptor *> openOutputs)
{
    SortedVector<audio_io_handle_t> outputs;

    ALOGVV("getOutputsForDevice() device %04x", device);
    for (size_t i = 0; i < openOutputs.size(); i++) {
        ALOGVV("output %d isDuplicated=%d device=%04x",
                i, openOutputs.valueAt(i)->isDuplicated(), openOutputs.valueAt(i)->supportedDevices());
        if ((device & openOutputs.valueAt(i)->supportedDevices()) == device) {    // 获取第 i 个元素的 value，并查看支持的设备
            ALOGVV("getOutputsForDevice() found output %d", openOutputs.keyAt(i));
            outputs.add(openOutputs.keyAt(i));    // 获取第 i 个元素的 key，并添加到 outputs 向量容器中
        }
    }
    return outputs;
}

        可以看到，openOutputs 是一个 DefaultKeyedVector 键值对类型的容器。在代码中，使用 openOutputs.size() 来获取到该容器中的元素个数，使用 openOutputs.valueAt(i) 来获取到该容器的第 i 个元素的 value 值，使用 openOutputs.keyAt(i) 来获取到该容器的第 i 个元素的 key 值。而 outputs 是一个 SortedVector 类型的容器。在代码中，使用 outputs.add() 方法来将从 openOutputs 中获取到的 key 值添加到 outputs 容器中。

【源码定义】

        DefaultKeyedVector 类型容器实际上是一个模板类，继承自 KeyedVector 模板类，实现在 KeyedVector.h 文件中。除了 size()、valueAt()、keyAt()、add() 方法之外，其它常用的方法还有譬如 isEmpty()、replaceValueAt()、removeItem() 等，均可在源码中找到。

KeyedVector 类定义如下：

template <typename KEY, typename VALUE>
class KeyedVector
{
public:
    typedef KEY    key_type;
    typedef VALUE  value_type;

    inline                  KeyedVector();

    /*
     * empty the vector
     */

    inline  void            clear()                     { mVector.clear(); }

    /*! 
     * vector stats
     */

    //! returns number of items in the vector
    inline  size_t          size() const                { return mVector.size(); }
    //! returns whether or not the vector is empty
    inline  bool            isEmpty() const             { return mVector.isEmpty(); }
    //! returns how many items can be stored without reallocating the backing store
    inline  size_t          capacity() const            { return mVector.capacity(); }
    //! sets the capacity. capacity can never be reduced less than size()
    inline ssize_t          setCapacity(size_t size)    { return mVector.setCapacity(size); }

    // returns true if the arguments is known to be identical to this vector
    inline bool isIdenticalTo(const KeyedVector& rhs) const;

    /*! 
     * accessors
     */
            const VALUE&    valueFor(const KEY& key) const;
            const VALUE&    valueAt(size_t index) const;
            const KEY&      keyAt(size_t index) const;
            ssize_t         indexOfKey(const KEY& key) const;
            const VALUE&    operator[] (size_t index) const;

    /*!
     * modifying the array
     */

            VALUE&          editValueFor(const KEY& key);
            VALUE&          editValueAt(size_t index);

            /*! 
             * add/insert/replace items
             */
             
            ssize_t         add(const KEY& key, const VALUE& item);
            ssize_t         replaceValueFor(const KEY& key, const VALUE& item);
            ssize_t         replaceValueAt(size_t index, const VALUE& item);

    /*!
     * remove items
     */

            ssize_t         removeItem(const KEY& key);
            ssize_t         removeItemsAt(size_t index, size_t count = 1);
            
private:
            SortedVector< key_value_pair_t<KEY, VALUE> >    mVector;    // 重要！将 key-value 整体作为 key_value_pair_t 元素存入到 SortedVector 中
};

        在 KeyedVctor 类声明的最后一行，我们看到实际上在内部将每个 key-value 键值对作为一个元素整体存入到 key_value_pair_t 模板结构体中，再把每个 key_value_pair_t 作为元素存入到一个名为 mVector 的 SortedVector 类型排序向量容器中。实际上在调用 valueAt()、keyAt() 等方法时，都是使用了 SortedVector 模板类和 key_value_pair_t 模板结构体的方法和特性。实现代码如下：

template<typename KEY, typename VALUE> inline
const VALUE& KeyedVector<KEY,VALUE>::valueAt(size_t index) const {
    return mVector.itemAt(index).value;    // 返回mVector中第index个key_value_pair_t元素的value
}


template<typename KEY, typename VALUE> inline
const KEY& KeyedVector<KEY,VALUE>::keyAt(size_t index) const {
    return mVector.itemAt(index).key;    // 返回mVector中第index个key_value_pair_t元素的key
}

DefaultKeyedVector 类是从 KeyedVector 类继承而来的，其定义如下：

/**
 * Variation of KeyedVector that holds a default value to return when
 * valueFor() is called with a key that doesn't exist.
 */
template <typename KEY, typename VALUE>
class DefaultKeyedVector : public KeyedVector<KEY, VALUE>
{
public:
    inline                  DefaultKeyedVector(const VALUE& defValue = VALUE());
            const VALUE&    valueFor(const KEY& key) const;

private:
            VALUE                                           mDefault;
};

        可以看到，相较于基类 KeyedVector 而言，DefaultKeyedVector 类只是添加了 valueFor() 方法和一个默认 value 值 mDefault。