This is an automated email from the ASF dual-hosted git repository.
ggregory pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-collections.git
The following commit(s) were added to refs/heads/master by this push:
new 08f7ffa0c Javadoc
08f7ffa0c is described below
commit 08f7ffa0c1cf531ea4db35071914a6eec25d5973
Author: Gary Gregory <garydgreg...@gmail.com>
AuthorDate: Fri Jun 14 21:37:07 2024 -0400
Javadoc
---
.../collections4/bidimap/AbstractDualBidiMap.java | 2 +-
.../commons/collections4/map/StaticBucketMap.java | 39 ++++++++++++++--------
2 files changed, 27 insertions(+), 14 deletions(-)
diff --git
a/src/main/java/org/apache/commons/collections4/bidimap/AbstractDualBidiMap.java
b/src/main/java/org/apache/commons/collections4/bidimap/AbstractDualBidiMap.java
index 62afd91ff..8a2a157a7 100644
---
a/src/main/java/org/apache/commons/collections4/bidimap/AbstractDualBidiMap.java
+++
b/src/main/java/org/apache/commons/collections4/bidimap/AbstractDualBidiMap.java
@@ -697,6 +697,7 @@ public abstract class AbstractDualBidiMap<K, V> implements
BidiMap<K, V> {
* The Map Entry setValue() method only allow a new value to be set.
* If the value being set is already in the map, an
IllegalArgumentException
* is thrown (as setValue cannot change the size of the map).
+ * </p>
*
* @return the entrySet view
*/
@@ -762,7 +763,6 @@ public abstract class AbstractDualBidiMap<K, V> implements
BidiMap<K, V> {
* Obtains a {@code MapIterator} over the map.
* The iterator implements {@link BidiMapIterator}.
* This implementation relies on the entrySet iterator.
- * <p>
*
* @return a map iterator
*/
diff --git
a/src/main/java/org/apache/commons/collections4/map/StaticBucketMap.java
b/src/main/java/org/apache/commons/collections4/map/StaticBucketMap.java
index d0ca28e67..441436f86 100644
--- a/src/main/java/org/apache/commons/collections4/map/StaticBucketMap.java
+++ b/src/main/java/org/apache/commons/collections4/map/StaticBucketMap.java
@@ -31,7 +31,9 @@ import org.apache.commons.collections4.KeyValue;
/**
* A StaticBucketMap is an efficient, thread-safe implementation of
* {@link java.util.Map} that performs well in a highly
- * thread-contentious environment. The map supports very efficient
+ * thread-contentious environment.
+ * <p>
+ * The map supports very efficient
* {@link #get(Object) get}, {@link #put(Object,Object) put},
* {@link #remove(Object) remove} and {@link #containsKey(Object) containsKey}
* operations, assuming (approximate) uniform hashing and
@@ -39,8 +41,9 @@ import org.apache.commons.collections4.KeyValue;
* number of entries exceeds the number of buckets or if the hash codes of the
* objects are not uniformly distributed, these operations have a worst case
* scenario that is proportional to the number of elements in the map
- * (<i>O(n)</i>).<p>
- *
+ * (<i>O(n)</i>).
+ * </p>
+ * <p>
* Each bucket in the hash table has its own monitor, so two threads can
* safely operate on the map at the same time, often without incurring any
* monitor contention. This means that you don't have to wrap instances
@@ -51,6 +54,7 @@ import org.apache.commons.collections4.KeyValue;
* {@link Collection#retainAll(Collection) retainAll} operation in collection
* views, are <i>not</i> atomic. If two threads are simultaneously
* executing
+ * </p>
*
* <pre>
* staticBucketMapInstance.putAll(map);
@@ -62,34 +66,41 @@ import org.apache.commons.collections4.KeyValue;
* staticBucketMapInstance.entrySet().removeAll(map.entrySet());
* </pre>
*
+ * <p>
* then the results are generally random. Those two statement could cancel
* each other out, leaving {@code staticBucketMapInstance} essentially
* unchanged, or they could leave some random subset of {@code map} in
- * {@code staticBucketMapInstance}.<p>
- *
+ * {@code staticBucketMapInstance}.
+ * </p>
+ * <p>
* Also, much like an encyclopedia, the results of {@link #size()} and
- * {@link #isEmpty()} are out-of-date as soon as they are produced.<p>
- *
+ * {@link #isEmpty()} are out-of-date as soon as they are produced.
+ * </p>
+ * <p>
* The iterators returned by the collection views of this class are <i>not</i>
* fail-fast. They will <i>never</i> raise a
* {@link java.util.ConcurrentModificationException}. Keys and values
* added to the map after the iterator is created do not necessarily appear
* during iteration. Similarly, the iterator does not necessarily fail to
- * return keys and values that were removed after the iterator was created.<p>
- *
+ * return keys and values that were removed after the iterator was created.
+ * </p>
+ * <p>
* Finally, unlike {@link java.util.HashMap}-style implementations, this
* class <i>never</i> rehashes the map. The number of buckets is fixed
* at construction time and never altered. Performance may degrade if
- * you do not allocate enough buckets upfront.<p>
- *
+ * you do not allocate enough buckets upfront.
+ * </p>
+ * <p>
* The {@link #atomic(Runnable)} method is provided to allow atomic iterations
* and bulk operations; however, overuse of {@link #atomic(Runnable) atomic}
* will basically result in a map that's slower than an ordinary synchronized
* {@link java.util.HashMap}.
- *
+ * </p>
+ * <p>
* Use this class if you do not require reliable bulk operations and
* iterations, or if you can make your own guarantees about how bulk
- * operations will affect the map.<p>
+ * operations will affect the map.
+ * </p>
*
* @param <K> the type of the keys in this map
* @param <V> the type of the values in this map
@@ -138,6 +149,7 @@ public final class StaticBucketMap<K, V> extends
AbstractIterableMap<K, V> {
last = null;
}
}
+
private final class EntryIterator extends BaseIterator implements
Iterator<Map.Entry<K, V>> {
@Override
@@ -146,6 +158,7 @@ public final class StaticBucketMap<K, V> extends
AbstractIterableMap<K, V> {
}
}
+
private final class EntrySet extends AbstractSet<Map.Entry<K, V>> {
@Override
