Returns a Map mapping each unique element in the given Collection to an Integer representing the number of occurrences of that element in the Collection .

Description

Demo Code


//package com.java2s;
import java.lang.reflect.Array;

import java.util.Collection;

import java.util.Enumeration;
import java.util.HashMap;

import java.util.Iterator;

import java.util.List;
import java.util.Map;

public class Main {
    public static void main(String[] argv) {
        Collection coll = java.util.Arrays.asList("asdf", "java2s.com");
        System.out.println(getCardinalityMap(coll));
    }/* w ww. j ava  2s  .c  om*/

    /** Constant to avoid repeated object creation */
    private static Integer INTEGER_ONE = new Integer(1);

    /**
     * Returns a {@link Map} mapping each unique element in the given
     * {@link Collection} to an {@link Integer} representing the number of
     * occurrences of that element in the {@link Collection}.
     * <p>
     * Only those elements present in the collection will appear as keys in the
     * map.
     * 
     * @param coll
     *            the collection to get the cardinality map for, must not be
     *            null
     * @return the populated cardinality map
     */
    public static <E> Map<E, Integer> getCardinalityMap(
            final Collection<E> coll) {
        if (coll == null) {
            return null;
        }
        Map<E, Integer> count = getHashMap();
        for (E e : coll) {
            Integer c = count.get(e);
            if (c == null) {
                count.put(e, INTEGER_ONE);
            } else {
                count.put(e, new Integer(c.intValue() + 1));
            }

        }

        return count;
    }

    public static <K, V> HashMap<K, V> getHashMap() {
        return new HashMap<K, V>();
    }

    public static <K, V> HashMap<K, V> getHashMap(int initialCapacity) {
        return new HashMap<K, V>(initialCapacity);
    }

    public static <K, V> HashMap<K, V> getHashMap(
            Map<? extends K, ? extends V> map) {
        return new HashMap<K, V>(map);
    }

    public static <K, V> HashMap<K, V> getHashMap(int initialCapacity,
            float loadFactor) {
        return new HashMap<K, V>(initialCapacity, loadFactor);
    }

    /**
     * Returns the <code>index</code>-th value in <code>object</code>, throwing
     * <code>IndexOutOfBoundsException</code> if there is no such element or
     * <code>IllegalArgumentException</code> if <code>object</code> is not an
     * instance of one of the supported types.
     * <p>
     * The supported types, and associated semantics are:
     * <ul>
     * <li>Map -- the value returned is the <code>Map.Entry</code> in position
     * <code>index</code> in the map's <code>entrySet</code> iterator, if there
     * is such an entry.</li>
     * <li>List -- this method is equivalent to the list's get method.</li>
     * <li>Array -- the <code>index</code>-th array entry is returned, if there
     * is such an entry; otherwise an <code>IndexOutOfBoundsException</code> is
     * thrown.</li>
     * <li>Collection -- the value returned is the <code>index</code>-th object
     * returned by the collection's default iterator, if there is such an
     * element.</li>
     * <li>Iterator or Enumeration -- the value returned is the
     * <code>index</code>-th object in the Iterator/Enumeration, if there is
     * such an element. The Iterator/Enumeration is advanced to
     * <code>index</code> (or to the end, if <code>index</code> exceeds the
     * number of entries) as a side effect of this method.</li>
     * </ul>
     * 
     * @param object
     *            the object to get a value from
     * @param index
     *            the index to get
     * @return the object at the specified index
     * @throws IndexOutOfBoundsException
     *             if the index is invalid
     * @throws IllegalArgumentException
     *             if the object type is invalid
     */
    public static Object get(Object object, int index) {
        if (index < 0) {
            throw new IndexOutOfBoundsException(
                    "Index cannot be negative: " + index);
        }
        if (object instanceof Map) {
            Map<?, ?> map = (Map<?, ?>) object;
            Iterator<?> iterator = map.entrySet().iterator();
            return get(iterator, index);
        } else if (object instanceof List) {
            return ((List<?>) object).get(index);
        } else if (object instanceof Object[]) {
            return ((Object[]) object)[index];
        } else if (object instanceof Iterator) {
            Iterator<?> it = (Iterator<?>) object;
            while (it.hasNext()) {
                index--;
                if (index == -1) {
                    return it.next();
                } else {
                    it.next();
                }
            }
            throw new IndexOutOfBoundsException("Entry does not exist: "
                    + index);
        } else if (object instanceof Collection) {
            Iterator<?> iterator = ((Collection<?>) object).iterator();
            return get(iterator, index);
        } else if (object instanceof Enumeration) {
            Enumeration<?> it = (Enumeration<?>) object;
            while (it.hasMoreElements()) {
                index--;
                if (index == -1) {
                    return it.nextElement();
                } else {
                    it.nextElement();
                }
            }
            throw new IndexOutOfBoundsException("Entry does not exist: "
                    + index);
        } else if (object == null) {
            throw new IllegalArgumentException(
                    "Unsupported object type: null");
        } else {
            try {
                return Array.get(object, index);
            } catch (IllegalArgumentException ex) {
                throw new IllegalArgumentException(
                        "Unsupported object type: "
                                + object.getClass().getName());
            }
        }
    }
}
Returns a Map mapping each unique element in the given Collection to an Integer representing the number of occurrences of that element in the Collection . - Java java.util

Description

Demo Code

Related Tutorials
