001/* 002 * Licensed to the Apache Software Foundation (ASF) under one or more 003 * contributor license agreements. See the NOTICE file distributed with 004 * this work for additional information regarding copyright ownership. 005 * The ASF licenses this file to You under the Apache License, Version 2.0 006 * (the "License"); you may not use this file except in compliance with 007 * the License. You may obtain a copy of the License at 008 * 009 * http://www.apache.org/licenses/LICENSE-2.0 010 * 011 * Unless required by applicable law or agreed to in writing, software 012 * distributed under the License is distributed on an "AS IS" BASIS, 013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 014 * See the License for the specific language governing permissions and 015 * limitations under the License. 016 */ 017package org.apache.commons.collections4.multimap; 018 019import java.io.IOException; 020import java.io.ObjectInputStream; 021import java.io.ObjectOutputStream; 022import java.io.Serializable; 023import java.util.ArrayList; 024import java.util.Collection; 025import java.util.LinkedHashMap; 026import java.util.Map; 027 028import org.apache.commons.collections4.MultiValuedMap; 029 030/** 031 * Implements a {@code ListValuedMap}, using a {@link LinkedHashMap} to provide data 032 * storage and {@link ArrayList}s as value collections. This is the standard 033 * implementation of a ListValuedMap. 034 * <p> 035 * <strong>Note that ArrayListValuedLinkedHashMap is not synchronized and is not 036 * thread-safe.</strong> If you wish to use this map from multiple threads 037 * concurrently, you must use appropriate synchronization. This class may throw 038 * exceptions when accessed by concurrent threads without synchronization. 039 * </p> 040 * 041 * @param <K> the type of the keys in this map 042 * @param <V> the type of the values in this map 043 * @since 4.5.0-M3 044 */ 045public class ArrayListValuedLinkedHashMap<K, V> extends AbstractListValuedMap<K, V> 046 implements Serializable { 047 048 /** Serialization Version */ 049 private static final long serialVersionUID = 20241014L; 050 051 /** 052 * The initial map capacity used when none specified in constructor. 053 */ 054 private static final int DEFAULT_INITIAL_MAP_CAPACITY = 16; 055 056 /** 057 * The initial list capacity when using none specified in constructor. 058 */ 059 private static final int DEFAULT_INITIAL_LIST_CAPACITY = 3; 060 061 /** 062 * The initial list capacity when creating a new value collection. 063 */ 064 private final int initialListCapacity; 065 066 /** 067 * Creates an empty ArrayListValuedHashMap with the default initial 068 * map capacity (16) and the default initial list capacity (3). 069 */ 070 public ArrayListValuedLinkedHashMap() { 071 this(DEFAULT_INITIAL_MAP_CAPACITY, DEFAULT_INITIAL_LIST_CAPACITY); 072 } 073 074 /** 075 * Creates an empty ArrayListValuedHashMap with the default initial 076 * map capacity (16) and the specified initial list capacity. 077 * 078 * @param initialListCapacity the initial capacity used for value collections 079 */ 080 public ArrayListValuedLinkedHashMap(final int initialListCapacity) { 081 this(DEFAULT_INITIAL_MAP_CAPACITY, initialListCapacity); 082 } 083 084 /** 085 * Creates an empty ArrayListValuedHashMap with the specified initial 086 * map and list capacities. 087 * 088 * @param initialMapCapacity the initial hashmap capacity 089 * @param initialListCapacity the initial capacity used for value collections 090 */ 091 public ArrayListValuedLinkedHashMap(final int initialMapCapacity, final int initialListCapacity) { 092 super(new LinkedHashMap<>(initialMapCapacity)); 093 this.initialListCapacity = initialListCapacity; 094 } 095 096 /** 097 * Creates an ArrayListValuedHashMap copying all the mappings of the given map. 098 * 099 * @param map a {@code Map} to copy into this map 100 */ 101 public ArrayListValuedLinkedHashMap(final Map<? extends K, ? extends V> map) { 102 this(map.size(), DEFAULT_INITIAL_LIST_CAPACITY); 103 super.putAll(map); 104 } 105 106 /** 107 * Creates an ArrayListValuedHashMap copying all the mappings of the given map. 108 * 109 * @param map a {@code MultiValuedMap} to copy into this map 110 */ 111 public ArrayListValuedLinkedHashMap(final MultiValuedMap<? extends K, ? extends V> map) { 112 this(map.size(), DEFAULT_INITIAL_LIST_CAPACITY); 113 super.putAll(map); 114 } 115 116 @Override 117 protected ArrayList<V> createCollection() { 118 return new ArrayList<>(initialListCapacity); 119 } 120 121 /** 122 * Deserializes an instance from an ObjectInputStream. 123 * 124 * @param in The source ObjectInputStream. 125 * @throws IOException Any of the usual Input/Output related exceptions. 126 * @throws ClassNotFoundException A class of a serialized object cannot be found. 127 */ 128 private void readObject(final ObjectInputStream in) throws IOException, ClassNotFoundException { 129 in.defaultReadObject(); 130 setMap(new LinkedHashMap<>()); 131 doReadObject(in); 132 } 133 134 /** 135 * Trims the capacity of all value collections to their current size. 136 */ 137 public void trimToSize() { 138 for (final Collection<V> coll : getMap().values()) { 139 final ArrayList<V> list = (ArrayList<V>) coll; 140 list.trimToSize(); 141 } 142 } 143 144 /** 145 * Serializes this object to an ObjectOutputStream. 146 * 147 * @param out the target ObjectOutputStream. 148 * @throws IOException thrown when an I/O errors occur writing to the target stream. 149 */ 150 private void writeObject(final ObjectOutputStream out) throws IOException { 151 out.defaultWriteObject(); 152 doWriteObject(out); 153 } 154 155}