/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.commons.collections4.map;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.Collection;
import java.util.Map;
import java.util.Set;

import org.apache.commons.collections4.BoundedMap;
import org.apache.commons.collections4.collection.UnmodifiableCollection;
import org.apache.commons.collections4.set.UnmodifiableSet;

Decorates another Map to fix the size, preventing add/remove.

Any action that would change the size of the map is disallowed. The put method is allowed to change the value associated with an existing key however.

If trying to remove or clear the map, an UnsupportedOperationException is thrown. If trying to put a new mapping into the map, an IllegalArgumentException is thrown. This is because the put method can succeed if the mapping's key already exists in the map, so the put method is not always unsupported.

Note that FixedSizeMap is not synchronized and is not thread-safe. If you wish to use this map from multiple threads concurrently, you must use appropriate synchronization. The simplest approach is to wrap this map using Collections.synchronizedMap(Map<Object,Object>). This class may throw exceptions when accessed by concurrent threads without synchronization.

This class is Serializable from Commons Collections 3.1.

Type parameters:
  • <K> – the type of the keys in this map
  • <V> – the type of the values in this map
Since:3.0
/** * Decorates another <code>Map</code> to fix the size, preventing add/remove. * <p> * Any action that would change the size of the map is disallowed. * The put method is allowed to change the value associated with an existing * key however. * </p> * <p> * If trying to remove or clear the map, an UnsupportedOperationException is * thrown. If trying to put a new mapping into the map, an * IllegalArgumentException is thrown. This is because the put method can * succeed if the mapping's key already exists in the map, so the put method * is not always unsupported. * </p> * <p> * <strong>Note that FixedSizeMap is not synchronized and is not thread-safe.</strong> * If you wish to use this map from multiple threads concurrently, you must use * appropriate synchronization. The simplest approach is to wrap this map * using {@link java.util.Collections#synchronizedMap(Map)}. This class may throw * exceptions when accessed by concurrent threads without synchronization. * </p> * <p> * This class is Serializable from Commons Collections 3.1. * </p> * * @param <K> the type of the keys in this map * @param <V> the type of the values in this map * @since 3.0 */
public class FixedSizeMap<K, V> extends AbstractMapDecorator<K, V> implements BoundedMap<K, V>, Serializable {
Serialization version
/** Serialization version */
private static final long serialVersionUID = 7450927208116179316L;
Factory method to create a fixed size map.
Params:
  • map – the map to decorate, must not be null
Type parameters:
  • <K> – the key type
  • <V> – the value type
Throws:
Returns:a new fixed size map
Since:4.0
/** * Factory method to create a fixed size map. * * @param <K> the key type * @param <V> the value type * @param map the map to decorate, must not be null * @return a new fixed size map * @throws NullPointerException if map is null * @since 4.0 */
public static <K, V> FixedSizeMap<K, V> fixedSizeMap(final Map<K, V> map) { return new FixedSizeMap<>(map); } //-----------------------------------------------------------------------
Constructor that wraps (not copies).
Params:
  • map – the map to decorate, must not be null
Throws:
/** * Constructor that wraps (not copies). * * @param map the map to decorate, must not be null * @throws NullPointerException if map is null */
protected FixedSizeMap(final Map<K, V> map) { super(map); } //-----------------------------------------------------------------------
Write the map out using a custom routine.
Params:
  • out – the output stream
Throws:
  • IOException – if an error occurs while writing to the stream
Since:3.1
/** * Write the map out using a custom routine. * * @param out the output stream * @throws IOException if an error occurs while writing to the stream * @since 3.1 */
private void writeObject(final ObjectOutputStream out) throws IOException { out.defaultWriteObject(); out.writeObject(map); }
Read the map in using a custom routine.
Params:
  • in – the input stream
Throws:
Since:3.1
/** * Read the map in using a custom routine. * * @param in the input stream * @throws IOException if an error occurs while reading from the stream * @throws ClassNotFoundException if an object read from the stream can not be loaded * @since 3.1 */
@SuppressWarnings("unchecked") // (1) should only fail if input stream is incorrect private void readObject(final ObjectInputStream in) throws IOException, ClassNotFoundException { in.defaultReadObject(); map = (Map<K, V>) in.readObject(); // (1) } //----------------------------------------------------------------------- @Override public V put(final K key, final V value) { if (map.containsKey(key) == false) { throw new IllegalArgumentException("Cannot put new key/value pair - Map is fixed size"); } return map.put(key, value); } @Override public void putAll(final Map<? extends K, ? extends V> mapToCopy) { for (final K key : mapToCopy.keySet()) { if (!containsKey(key)) { throw new IllegalArgumentException("Cannot put new key/value pair - Map is fixed size"); } } map.putAll(mapToCopy); } @Override public void clear() { throw new UnsupportedOperationException("Map is fixed size"); } @Override public V remove(final Object key) { throw new UnsupportedOperationException("Map is fixed size"); } @Override public Set<Map.Entry<K, V>> entrySet() { final Set<Map.Entry<K, V>> set = map.entrySet(); // unmodifiable set will still allow modification via Map.Entry objects return UnmodifiableSet.unmodifiableSet(set); } @Override public Set<K> keySet() { final Set<K> set = map.keySet(); return UnmodifiableSet.unmodifiableSet(set); } @Override public Collection<V> values() { final Collection<V> coll = map.values(); return UnmodifiableCollection.unmodifiableCollection(coll); } @Override public boolean isFull() { return true; } @Override public int maxSize() { return size(); } }