Added version information. Fixed misc 'random.next' typos

src/dorkbox/collections/Array.java

@@ -28,6 +28,8 @@ import java.util.NoSuchElementException;
  * @author Nathan Sweet */
 @SuppressWarnings({"unchecked", "rawtypes", "SuspiciousSystemArraycopy", "unused", "NullableProblems", "DuplicatedCode"})
 public class Array<T> implements Iterable<T> {
+    public static final String version = Collections.version;
+
 	/** Provides direct access to the underlying array. If the Array's generic type is not Object, this field may only be accessed
 	 * if the {@link Array#Array(boolean, int, Class)} constructor was used. */
 	public T[] items;
@@ -438,7 +440,7 @@ public class Array<T> implements Iterable<T> {
 	public void shuffle () {
 		T[] items = this.items;
 		for (int i = size - 1; i >= 0; i--) {
-			int ii = MathUtil.random(i);
+			int ii = Collections.INSTANCE.random(i);
 			T temp = items[i];
 			items[i] = items[ii];
 			items[ii] = temp;
@@ -477,7 +479,7 @@ public class Array<T> implements Iterable<T> {
 	/** Returns a random item from the array, or null if the array is empty. */
 	public T random () {
 		if (size == 0) return null;
-		return items[MathUtil.random(0, size - 1)];
+		return items[Collections.random(0, size - 1)];
 	}
 
 	/** Returns the items as an array. Note the array is typed, so the {@link #Array(Class)} constructor must have been used.

src/dorkbox/collections/ArrayMap.java

@@ -31,6 +31,8 @@ import dorkbox.collections.ObjectMap.Entry;
  * @author Nathan Sweet */
 @SuppressWarnings({"unchecked", "rawtypes", "unused", "SuspiciousSystemArraycopy", "NullableProblems"})
 public class ArrayMap<K, V> implements Iterable<Entry<K, V>> {
+    public static final String version = Collections.version;
+
 	public K[] keys;
 	public V[] values;
 	public int size;
@@ -384,7 +386,7 @@ public class ArrayMap<K, V> implements Iterable<Entry<K, V>> {
 
 	public void shuffle () {
 		for (int i = size - 1; i >= 0; i--) {
-			int ii = MathUtil.random(i);
+			int ii = Collections.INSTANCE.random(i);
 			K tempKey = keys[i];
 			keys[i] = keys[ii];
 			keys[ii] = tempKey;

src/dorkbox/collections/BinarySearch.java

@@ -43,6 +43,7 @@ import java.util.List;
  * @author Tim Boudreau
  */
 public class BinarySearch<T> {
+    public static final String version = Collections.version;
 
     private final Evaluator<T> eval;
     private final Indexed<T> indexed;

src/dorkbox/collections/BooleanArray.java

@@ -26,6 +26,8 @@ import java.util.BitSet;
  * removing elements (the last element is moved to the removed element's position).
  * @author Nathan Sweet */
 public class BooleanArray {
+    public static final String version = Collections.version;
+
 	public boolean[] items;
 	public int size;
 	public boolean ordered;
@@ -281,7 +283,7 @@ public class BooleanArray {
 	public void shuffle () {
 		boolean[] items = this.items;
 		for (int i = size - 1; i >= 0; i--) {
-			int ii = MathUtil.random(i);
+			int ii = Collections.INSTANCE.random(i);
 			boolean temp = items[i];
 			items[i] = items[ii];
 			items[ii] = temp;
@@ -297,7 +299,7 @@ public class BooleanArray {
 	/** Returns a random item from the array, or false if the array is empty. */
 	public boolean random () {
 		if (size == 0) return false;
-		return items[MathUtil.random(0, size - 1)];
+		return items[Collections.random(0, size - 1)];
 	}
 
 	public boolean[] toArray () {

src/dorkbox/collections/ByteArray.java

@@ -24,6 +24,8 @@ import java.util.Arrays;
  * avoids a memory copy when removing elements (the last element is moved to the removed element's position).
  * @author Nathan Sweet */
 public class ByteArray {
+    public static final String version = Collections.version;
+
 	public byte[] items;
 	public int size;
 	public boolean ordered;
@@ -326,7 +328,7 @@ public class ByteArray {
 	public void shuffle () {
 		byte[] items = this.items;
 		for (int i = size - 1; i >= 0; i--) {
-			int ii = MathUtil.random(i);
+			int ii = Collections.INSTANCE.random(i);
 			byte temp = items[i];
 			items[i] = items[ii];
 			items[ii] = temp;
@@ -342,7 +344,7 @@ public class ByteArray {
 	/** Returns a random item from the array, or zero if the array is empty. */
 	public byte random () {
 		if (size == 0) return 0;
-		return items[MathUtil.random(0, size - 1)];
+		return items[Collections.random(0, size - 1)];
 	}
 
 	public byte[] toArray () {

src/dorkbox/collections/CharArray.java

@@ -24,6 +24,8 @@ import java.util.Arrays;
  * class avoids a memory copy when removing elements (the last element is moved to the removed element's position).
  * @author Nathan Sweet */
 public class CharArray {
+    public static final String version = Collections.version;
+
 	public char[] items;
 	public int size;
 	public boolean ordered;
@@ -326,7 +328,7 @@ public class CharArray {
 	public void shuffle () {
 		char[] items = this.items;
 		for (int i = size - 1; i >= 0; i--) {
-			int ii = MathUtil.random(i);
+			int ii = Collections.INSTANCE.random(i);
 			char temp = items[i];
 			items[i] = items[ii];
 			items[ii] = temp;
@@ -342,7 +344,7 @@ public class CharArray {
 	/** Returns a random item from the array, or zero if the array is empty. */
 	public char random () {
 		if (size == 0) return 0;
-		return items[MathUtil.random(0, size - 1)];
+		return items[Collections.random(0, size - 1)];
 	}
 
 	public char[] toArray () {

src/dorkbox/collections/Collections.kt

@@ -13,30 +13,39 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package dorkbox.collections;
+package dorkbox.collections
 
+import java.util.*
 
-import java.util.Random;
+object Collections {
+    /**
+     * Gets the version number.
+     */
+    const val version = "1.0"
 
-public
-class MathUtil {
-    public static final Random random = new Random();
-
-    /** Returns a random number between 0 (inclusive) and the specified value (inclusive). */
-    static public int random (int range) {
-        return random.nextInt(range + 1);
+    init {
+        // Add this project to the updates system, which verifies this class + UUID + version information
+        dorkbox.updates.Updates.add(java.util.Collections::class.java, "7a4be173d7fd48e4a09543cc572eb903", version)
     }
 
-    /** Returns a random number between start (inclusive) and end (inclusive). */
-    static public int random (int start, int end) {
-        return start + random.nextInt(end - start + 1);
+    internal val random = Random()
+
+    /** Returns a random number between 0 (inclusive) and the specified value (inclusive).  */
+    fun random(range: Int): Int {
+        return random.nextInt(range + 1)
+    }
+
+    /** Returns a random number between start (inclusive) and end (inclusive).  */
+    @JvmStatic
+    fun random(start: Int, end: Int): Int {
+        return start + random.nextInt(end - start + 1)
     }
 
     /**
      * Returns the next power of two. Returns the specified value if the value is already a power of two.
      */
-    public static
-    int nextPowerOfTwo(int value) {
-        return 1 << (32 - Integer.numberOfLeadingZeros(value - 1));
+    @JvmStatic
+    fun nextPowerOfTwo(value: Int): Int {
+        return 1 shl 32 - Integer.numberOfLeadingZeros(value - 1)
     }
 }

src/dorkbox/collections/ComparableTimSort.java

@@ -21,6 +21,8 @@ package dorkbox.collections;
  * conjunction with a comparator that simply returns {@code ((Comparable)first).compareTo(Second)}. If this is the case, you are
  * better off deleting ComparableTimSort to eliminate the code duplication. (See Arrays.java for details.) */
 class ComparableTimSort {
+    public static final String version = Collections.version;
+
 	/** This is the minimum sized sequence that will be merged. Shorter sequences will be lengthened by calling binarySort. If the
 	 * entire array is less than this length, no merges will be performed.
 	 *

src/dorkbox/collections/ConcurrentEntry.java

@@ -25,6 +25,8 @@ package dorkbox.collections;
  */
 public
 class ConcurrentEntry<T> {
+    public static final String version = Collections.version;
+
     private final T value;
 
     private volatile ConcurrentEntry<T> next;

src/dorkbox/collections/ConcurrentIterator.java

@@ -25,6 +25,8 @@ import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
 @SuppressWarnings("unchecked")
 public
 class ConcurrentIterator<T> {
+    public static final String version = Collections.version;
+
     /**
      * Specifies the load-factor for the IdentityMap used
      */

src/dorkbox/collections/ConcurrentWeakIdentityHashMap.java

@@ -36,6 +36,7 @@ import java.util.concurrent.ConcurrentMap;
  * @author zhanhb
  */
 class ConcurrentWeakIdentityHashMap<K, V> extends AbstractMap<K, V> implements ConcurrentMap<K, V> {
+    public static final String version = Collections.version;
 
     private final ConcurrentMap<Key<K>, V> map;
     private final ReferenceQueue<K> queue = new ReferenceQueue<>();

src/dorkbox/collections/FloatArray.java

@@ -19,12 +19,13 @@
 package dorkbox.collections;
 
 import java.util.Arrays;
-import java.util.Random;
 
 /** A resizable, ordered or unordered float array. Avoids the boxing that occurs with ArrayList<Float>. If unordered, this class
  * avoids a memory copy when removing elements (the last element is moved to the removed element's position).
  * @author Nathan Sweet */
 public class FloatArray {
+    public static final String version = Collections.version;
+
 	public float[] items;
 	public int size;
 	public boolean ordered;
@@ -327,7 +328,7 @@ public class FloatArray {
 	public void shuffle () {
 		float[] items = this.items;
 		for (int i = size - 1; i >= 0; i--) {
-			int ii = MathUtil.random(i);
+			int ii = Collections.INSTANCE.random(i);
 			float temp = items[i];
 			items[i] = items[ii];
 			items[ii] = temp;
@@ -343,7 +344,7 @@ public class FloatArray {
 	/** Returns a random item from the array, or zero if the array is empty. */
 	public float random () {
 		if (size == 0) return 0;
-		return items[MathUtil.random(0, size - 1)];
+		return items[Collections.random(0, size - 1)];
 	}
 
 	public float[] toArray () {

src/dorkbox/collections/IdentityMap.java

@@ -31,6 +31,8 @@ import java.util.NoSuchElementException;
  * @author Nathan Sweet */
 @SuppressWarnings({"unchecked", "rawtypes", "NullableProblems"})
 public class IdentityMap<K, V> implements Iterable<IdentityMap.Entry<K, V>> {
+    public static final String version = Collections.version;
+
 	private static final int PRIME1 = 0xbe1f14b1;
 	private static final int PRIME2 = 0xb4b82e39;
 	private static final int PRIME3 = 0xced1c241;
@@ -66,7 +68,7 @@ public class IdentityMap<K, V> implements Iterable<IdentityMap.Entry<K, V>> {
 	 * @param initialCapacity If not a power of two, it is increased to the next nearest power of two. */
 	public IdentityMap (int initialCapacity, float loadFactor) {
 		if (initialCapacity < 0) throw new IllegalArgumentException("initialCapacity must be >= 0: " + initialCapacity);
-		initialCapacity = MathUtil.nextPowerOfTwo((int)Math.ceil(initialCapacity / loadFactor));
+		initialCapacity = Collections.nextPowerOfTwo((int)Math.ceil(initialCapacity / loadFactor));
 		if (initialCapacity > 1 << 30) throw new IllegalArgumentException("initialCapacity is too large: " + initialCapacity);
 		capacity = initialCapacity;
 
@@ -202,7 +204,7 @@ public class IdentityMap<K, V> implements Iterable<IdentityMap.Entry<K, V>> {
 		int i = 0, pushIterations = this.pushIterations;
 		do {
 			// Replace the key and value for one of the hashes.
-			switch (MathUtil.random.nextInt(2)) {
+			switch (Collections.INSTANCE.random(2)) {
 			case 0:
 				evictedKey = key1;
 				evictedValue = valueTable[index1];
@@ -377,7 +379,7 @@ public class IdentityMap<K, V> implements Iterable<IdentityMap.Entry<K, V>> {
 		if (maximumCapacity < 0) throw new IllegalArgumentException("maximumCapacity must be >= 0: " + maximumCapacity);
 		if (size > maximumCapacity) maximumCapacity = size;
 		if (capacity <= maximumCapacity) return;
-		maximumCapacity = MathUtil.nextPowerOfTwo(maximumCapacity);
+		maximumCapacity = Collections.nextPowerOfTwo(maximumCapacity);
 		resize(maximumCapacity);
 	}
 
@@ -468,7 +470,7 @@ public class IdentityMap<K, V> implements Iterable<IdentityMap.Entry<K, V>> {
 	public void ensureCapacity (int additionalCapacity) {
 		if (additionalCapacity < 0) throw new IllegalArgumentException("additionalCapacity must be >= 0: " + additionalCapacity);
 		int sizeNeeded = size + additionalCapacity;
-		if (sizeNeeded >= threshold) resize(MathUtil.nextPowerOfTwo((int)Math.ceil(sizeNeeded / loadFactor)));
+		if (sizeNeeded >= threshold) resize(Collections.nextPowerOfTwo((int)Math.ceil(sizeNeeded / loadFactor)));
 	}
 
 	private void resize (int newSize) {

src/dorkbox/collections/IntArray.java

@@ -24,6 +24,8 @@ import java.util.Arrays;
  * avoids a memory copy when removing elements (the last element is moved to the removed element's position).
  * @author Nathan Sweet */
 public class IntArray {
+    public static final String version = Collections.version;
+
     public int[] items;
     public int size;
     public boolean ordered;
@@ -326,7 +328,7 @@ public class IntArray {
     public void shuffle () {
         int[] items = this.items;
         for (int i = size - 1; i >= 0; i--) {
-            int ii = MathUtil.random(i);
+            int ii = Collections.INSTANCE.random(i);
             int temp = items[i];
             items[i] = items[ii];
             items[ii] = temp;
@@ -342,7 +344,7 @@ public class IntArray {
     /** Returns a random item from the array, or zero if the array is empty. */
     public int random () {
         if (size == 0) return 0;
-        return items[MathUtil.random(0, size - 1)];
+        return items[Collections.random(0, size - 1)];
     }
 
     public int[] toArray () {

src/dorkbox/collections/IntFloatMap.java

@@ -30,7 +30,9 @@ import java.util.NoSuchElementException;
  * next higher POT size.
  * @author Nathan Sweet */
 public class IntFloatMap implements Iterable<IntFloatMap.Entry> {
-	private static final int PRIME1 = 0xbe1f14b1;
+    public static final String version = Collections.version;
+
+    private static final int PRIME1 = 0xbe1f14b1;
 	private static final int PRIME2 = 0xb4b82e39;
 	private static final int PRIME3 = 0xced1c241;
 	private static final int EMPTY = 0;
@@ -68,7 +70,7 @@ public class IntFloatMap implements Iterable<IntFloatMap.Entry> {
 	 * @param initialCapacity If not a power of two, it is increased to the next nearest power of two. */
 	public IntFloatMap (int initialCapacity, float loadFactor) {
 		if (initialCapacity < 0) throw new IllegalArgumentException("initialCapacity must be >= 0: " + initialCapacity);
-		initialCapacity = MathUtil.nextPowerOfTwo((int)Math.ceil(initialCapacity / loadFactor));
+		initialCapacity = Collections.nextPowerOfTwo((int)Math.ceil(initialCapacity / loadFactor));
 		if (initialCapacity > 1 << 30) throw new IllegalArgumentException("initialCapacity is too large: " + initialCapacity);
 		capacity = initialCapacity;
 
@@ -218,7 +220,7 @@ public class IntFloatMap implements Iterable<IntFloatMap.Entry> {
 		int i = 0, pushIterations = this.pushIterations;
 		do {
 			// Replace the key and value for one of the hashes.
-			switch (MathUtil.random(2)) {
+			switch (Collections.INSTANCE.random(2)) {
 			case 0:
 				evictedKey = key1;
 				evictedValue = valueTable[index1];
@@ -424,7 +426,7 @@ public class IntFloatMap implements Iterable<IntFloatMap.Entry> {
 		if (maximumCapacity < 0) throw new IllegalArgumentException("maximumCapacity must be >= 0: " + maximumCapacity);
 		if (size > maximumCapacity) maximumCapacity = size;
 		if (capacity <= maximumCapacity) return;
-		maximumCapacity = MathUtil.nextPowerOfTwo(maximumCapacity);
+		maximumCapacity = Collections.nextPowerOfTwo(maximumCapacity);
 		resize(maximumCapacity);
 	}
 
@@ -506,7 +508,7 @@ public class IntFloatMap implements Iterable<IntFloatMap.Entry> {
 	public void ensureCapacity (int additionalCapacity) {
 		if (additionalCapacity < 0) throw new IllegalArgumentException("additionalCapacity must be >= 0: " + additionalCapacity);
 		int sizeNeeded = size + additionalCapacity;
-		if (sizeNeeded >= threshold) resize(MathUtil.nextPowerOfTwo((int)Math.ceil(sizeNeeded / loadFactor)));
+		if (sizeNeeded >= threshold) resize(Collections.nextPowerOfTwo((int)Math.ceil(sizeNeeded / loadFactor)));
 	}
 
 	private void resize (int newSize) {

src/dorkbox/collections/IntIntMap.java

@@ -29,7 +29,9 @@ import java.util.NoSuchElementException;
  * next higher POT size.
  * @author Nathan Sweet */
 public class IntIntMap implements Iterable<IntIntMap.Entry> {
-	private static final int PRIME1 = 0xbe1f14b1;
+    public static final String version = Collections.version;
+
+    private static final int PRIME1 = 0xbe1f14b1;
 	private static final int PRIME2 = 0xb4b82e39;
 	private static final int PRIME3 = 0xced1c241;
 	private static final int EMPTY = 0;
@@ -66,7 +68,7 @@ public class IntIntMap implements Iterable<IntIntMap.Entry> {
 	 * @param initialCapacity If not a power of two, it is increased to the next nearest power of two. */
 	public IntIntMap (int initialCapacity, float loadFactor) {
 		if (initialCapacity < 0) throw new IllegalArgumentException("initialCapacity must be >= 0: " + initialCapacity);
-		initialCapacity = MathUtil.nextPowerOfTwo((int)Math.ceil(initialCapacity / loadFactor));
+		initialCapacity = Collections.nextPowerOfTwo((int)Math.ceil(initialCapacity / loadFactor));
 		if (initialCapacity > 1 << 30) throw new IllegalArgumentException("initialCapacity is too large: " + initialCapacity);
 		capacity = initialCapacity;
 
@@ -216,7 +218,7 @@ public class IntIntMap implements Iterable<IntIntMap.Entry> {
 		int i = 0, pushIterations = this.pushIterations;
 		do {
 			// Replace the key and value for one of the hashes.
-			switch (MathUtil.random(2)) {
+			switch (Collections.INSTANCE.random(2)) {
 			case 0:
 				evictedKey = key1;
 				evictedValue = valueTable[index1];
@@ -422,7 +424,7 @@ public class IntIntMap implements Iterable<IntIntMap.Entry> {
 		if (maximumCapacity < 0) throw new IllegalArgumentException("maximumCapacity must be >= 0: " + maximumCapacity);
 		if (size > maximumCapacity) maximumCapacity = size;
 		if (capacity <= maximumCapacity) return;
-		maximumCapacity = MathUtil.nextPowerOfTwo(maximumCapacity);
+		maximumCapacity = Collections.nextPowerOfTwo(maximumCapacity);
 		resize(maximumCapacity);
 	}
 
@@ -492,7 +494,7 @@ public class IntIntMap implements Iterable<IntIntMap.Entry> {
 	public void ensureCapacity (int additionalCapacity) {
 		if (additionalCapacity < 0) throw new IllegalArgumentException("additionalCapacity must be >= 0: " + additionalCapacity);
 		int sizeNeeded = size + additionalCapacity;
-		if (sizeNeeded >= threshold) resize(MathUtil.nextPowerOfTwo((int)Math.ceil(sizeNeeded / loadFactor)));
+		if (sizeNeeded >= threshold) resize(Collections.nextPowerOfTwo((int)Math.ceil(sizeNeeded / loadFactor)));
 	}
 
 	private void resize (int newSize) {

src/dorkbox/collections/IntMap.java

@@ -20,7 +20,6 @@ package dorkbox.collections;
 
 import java.util.Iterator;
 import java.util.NoSuchElementException;
-import java.util.Random;
 
 /** An unordered map that uses int keys. This implementation is a cuckoo hash map using 3 hashes, random walking, and a small
  * stash for problematic keys. Null values are allowed. No allocation is done except when growing the table size. <br>
@@ -31,6 +30,8 @@ import java.util.Random;
  * @author Nathan Sweet */
 @SuppressWarnings({"unchecked", "rawtypes"})
 public class IntMap<V> implements Iterable<IntMap.Entry<V>> {
+    public static final String version = Collections.version;
+
     private static final int PRIME1 = 0xbe1f14b1;
     private static final int PRIME2 = 0xb4b82e39;
     private static final int PRIME3 = 0xced1c241;
@@ -69,7 +70,7 @@ public class IntMap<V> implements Iterable<IntMap.Entry<V>> {
      * @param initialCapacity If not a power of two, it is increased to the next nearest power of two. */
     public IntMap (int initialCapacity, float loadFactor) {
         if (initialCapacity < 0) throw new IllegalArgumentException("initialCapacity must be >= 0: " + initialCapacity);
-        initialCapacity = MathUtil.nextPowerOfTwo((int)Math.ceil(initialCapacity / loadFactor));
+        initialCapacity = Collections.nextPowerOfTwo((int)Math.ceil(initialCapacity / loadFactor));
         if (initialCapacity > 1 << 30) throw new IllegalArgumentException("initialCapacity is too large: " + initialCapacity);
         capacity = initialCapacity;
 
@@ -226,7 +227,7 @@ public class IntMap<V> implements Iterable<IntMap.Entry<V>> {
         int i = 0, pushIterations = this.pushIterations;
         do {
             // Replace the key and value for one of the hashes.
-            switch (MathUtil.random.nextInt(2)) {
+            switch (Collections.INSTANCE.random(2)) {
                 case 0:
                     evictedKey = key1;
                     evictedValue = valueTable[index1];
@@ -414,7 +415,7 @@ public class IntMap<V> implements Iterable<IntMap.Entry<V>> {
         if (maximumCapacity < 0) throw new IllegalArgumentException("maximumCapacity must be >= 0: " + maximumCapacity);
         if (size > maximumCapacity) maximumCapacity = size;
         if (capacity <= maximumCapacity) return;
-        maximumCapacity = MathUtil.nextPowerOfTwo(maximumCapacity);
+        maximumCapacity = Collections.nextPowerOfTwo(maximumCapacity);
         resize(maximumCapacity);
     }
 
@@ -515,7 +516,7 @@ public class IntMap<V> implements Iterable<IntMap.Entry<V>> {
     public void ensureCapacity (int additionalCapacity) {
         if (additionalCapacity < 0) throw new IllegalArgumentException("additionalCapacity must be >= 0: " + additionalCapacity);
         int sizeNeeded = size + additionalCapacity;
-        if (sizeNeeded >= threshold) resize(MathUtil.nextPowerOfTwo((int)Math.ceil(sizeNeeded / loadFactor)));
+        if (sizeNeeded >= threshold) resize(Collections.nextPowerOfTwo((int)Math.ceil(sizeNeeded / loadFactor)));
     }
 
     private void resize (int newSize) {

src/dorkbox/collections/IntSet.java

@@ -19,7 +19,6 @@
 package dorkbox.collections;
 
 import java.util.NoSuchElementException;
-import java.util.Random;
 
 /** An unordered set that uses int keys. This implementation uses cuckoo hashing using 3 hashes, random walking, and a small stash
  * for problematic keys. No allocation is done except when growing the table size. <br>
@@ -29,7 +28,9 @@ import java.util.Random;
  * size.
  * @author Nathan Sweet */
 public class IntSet {
-	private static final int PRIME1 = 0xbe1f14b1;
+    public static final String version = Collections.version;
+
+    private static final int PRIME1 = 0xbe1f14b1;
 	private static final int PRIME2 = 0xb4b82e39;
 	private static final int PRIME3 = 0xced1c241;
 	private static final int EMPTY = 0;
@@ -63,7 +64,7 @@ public class IntSet {
 	 * @param initialCapacity If not a power of two, it is increased to the next nearest power of two. */
 	public IntSet (int initialCapacity, float loadFactor) {
 		if (initialCapacity < 0) throw new IllegalArgumentException("initialCapacity must be >= 0: " + initialCapacity);
-		initialCapacity = MathUtil.nextPowerOfTwo((int)Math.ceil(initialCapacity / loadFactor));
+		initialCapacity = Collections.nextPowerOfTwo((int)Math.ceil(initialCapacity / loadFactor));
 		if (initialCapacity > 1 << 30) throw new IllegalArgumentException("initialCapacity is too large: " + initialCapacity);
 		capacity = initialCapacity;
 
@@ -211,7 +212,7 @@ public class IntSet {
 		int i = 0, pushIterations = this.pushIterations;
 		do {
 			// Replace the key and value for one of the hashes.
-			switch (MathUtil.random.nextInt(2)) {
+			switch (Collections.INSTANCE.random(2)) {
 			case 0:
 				evictedKey = key1;
 				keyTable[index1] = insertKey;
@@ -336,7 +337,7 @@ public class IntSet {
 		if (maximumCapacity < 0) throw new IllegalArgumentException("maximumCapacity must be >= 0: " + maximumCapacity);
 		if (size > maximumCapacity) maximumCapacity = size;
 		if (capacity <= maximumCapacity) return;
-		maximumCapacity = MathUtil.nextPowerOfTwo(maximumCapacity);
+		maximumCapacity = Collections.nextPowerOfTwo(maximumCapacity);
 		resize(maximumCapacity);
 	}
 
@@ -394,7 +395,7 @@ public class IntSet {
 	public void ensureCapacity (int additionalCapacity) {
 		if (additionalCapacity < 0) throw new IllegalArgumentException("additionalCapacity must be >= 0: " + additionalCapacity);
 		int sizeNeeded = size + additionalCapacity;
-		if (sizeNeeded >= threshold) resize(MathUtil.nextPowerOfTwo((int)Math.ceil(sizeNeeded / loadFactor)));
+		if (sizeNeeded >= threshold) resize(Collections.nextPowerOfTwo((int)Math.ceil(sizeNeeded / loadFactor)));
 	}
 
 	private void resize (int newSize) {

src/dorkbox/collections/LockFreeArrayList.java

@@ -39,6 +39,8 @@ import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
  */
 public final
 class LockFreeArrayList<E> implements List<E>, RandomAccess, Cloneable, Serializable {
+    public static final String version = Collections.version;
+
     // Recommended for best performance while adhering to the "single writer principle". Must be static-final
     private static final AtomicReferenceFieldUpdater<LockFreeArrayList, ArrayList> listRef =
             AtomicReferenceFieldUpdater.newUpdater(LockFreeArrayList.class,
@@ -107,9 +109,9 @@ class LockFreeArrayList<E> implements List<E>, RandomAccess, Cloneable, Serializ
     }
 
 
+    @SuppressWarnings("unchecked")
     public
     E get(int index) {
-        //noinspection unchecked
         return (E) listRef.get(this).get(index);
     }
 
@@ -156,6 +158,7 @@ class LockFreeArrayList<E> implements List<E>, RandomAccess, Cloneable, Serializ
 
 
     // lock-free get
+    @SuppressWarnings("unchecked")
     @Override
     public
     ListIterator<E> listIterator() {
@@ -163,6 +166,7 @@ class LockFreeArrayList<E> implements List<E>, RandomAccess, Cloneable, Serializ
     }
 
     // lock-free get
+    @SuppressWarnings("unchecked")
     @Override
     public
     ListIterator<E> listIterator(final int index) {
@@ -170,6 +174,7 @@ class LockFreeArrayList<E> implements List<E>, RandomAccess, Cloneable, Serializ
     }
 
     // lock-free get
+    @SuppressWarnings("unchecked")
     @Override
     public
     List<E> subList(final int startIndex, final int endIndex) {
@@ -185,10 +190,10 @@ class LockFreeArrayList<E> implements List<E>, RandomAccess, Cloneable, Serializ
     }
 
     // lock-free get
+    @SuppressWarnings("unchecked")
     @Override
     public
     boolean containsAll(final Collection<?> collection) {
-        //noinspection unchecked
         return listRef.get(this).containsAll(collection);
     }
 
@@ -213,6 +218,7 @@ class LockFreeArrayList<E> implements List<E>, RandomAccess, Cloneable, Serializ
     }
 
     // lock-free get
+    @SuppressWarnings("unchecked")
     @Override
     public
     Iterator<E> iterator() {
@@ -227,10 +233,10 @@ class LockFreeArrayList<E> implements List<E>, RandomAccess, Cloneable, Serializ
     }
 
     // lock-free get
+    @SuppressWarnings("unchecked")
     @Override
     public
     <T> T[] toArray(final T[] targetArray) {
-        //noinspection unchecked
         return (T[]) listRef.get(this).toArray(targetArray);
     }
 

src/dorkbox/collections/LockFreeBiMap.java

@@ -39,6 +39,8 @@ import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
 @SuppressWarnings("WeakerAccess")
 public final
 class LockFreeBiMap<K, V> {
+    public static final String version = Collections.version;
+
     // Recommended for best performance while adhering to the "single writer principle". Must be static-final
     private static final AtomicReferenceFieldUpdater<LockFreeBiMap, HashMap> forwardREF =
                     AtomicReferenceFieldUpdater.newUpdater(LockFreeBiMap.class,

src/dorkbox/collections/LockFreeHashMap.java

@@ -39,6 +39,8 @@ import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
  */
 public final
 class LockFreeHashMap<K, V> implements Map<K, V>, Cloneable, Serializable {
+    public static final String version = dorkbox.collections.Collections.version;
+
     // Recommended for best performance while adhering to the "single writer principle". Must be static-final
     private static final AtomicReferenceFieldUpdater<LockFreeHashMap, HashMap> mapREF = AtomicReferenceFieldUpdater.newUpdater(
             LockFreeHashMap.class,

src/dorkbox/collections/LockFreeHashSet.java

@@ -38,6 +38,8 @@ import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
  */
 public final
 class LockFreeHashSet<E> implements Set<E>, Cloneable, Serializable {
+    public static final String version = Collections.version;
+
     // Recommended for best performance while adhering to the "single writer principle". Must be static-final
     private static final AtomicReferenceFieldUpdater<LockFreeHashSet, Set> setREF =
             AtomicReferenceFieldUpdater.newUpdater(LockFreeHashSet.class,
@@ -71,6 +73,7 @@ class LockFreeHashSet<E> implements Set<E>, Cloneable, Serializable {
         return hashSet.add(element);
     }
 
+    @SuppressWarnings("unchecked")
     @Override
     public
     boolean containsAll(final Collection<?> collection) {
@@ -133,10 +136,10 @@ class LockFreeHashSet<E> implements Set<E>, Cloneable, Serializable {
     }
 
     // lock-free get
+    @SuppressWarnings("unchecked")
     @Override
     public
     Iterator<E> iterator() {
-        //noinspection unchecked
         return setREF.get(this).iterator();
     }
 
@@ -148,10 +151,10 @@ class LockFreeHashSet<E> implements Set<E>, Cloneable, Serializable {
     }
 
     // lock-free get
+    @SuppressWarnings("unchecked")
     @Override
     public
     <T> T[] toArray(final T[] targetArray) {
-        //noinspection unchecked
         return (T[]) setREF.get(this).toArray(targetArray);
     }
 }

src/dorkbox/collections/LockFreeIntBiMap.java

@@ -40,6 +40,8 @@ import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
  */
 public
 class LockFreeIntBiMap<V> {
+    public static final String version = Collections.version;
+
     // Recommended for best performance while adhering to the "single writer principle". Must be static-final
     private static final AtomicReferenceFieldUpdater<LockFreeIntBiMap, IntMap> forwardREF = AtomicReferenceFieldUpdater.newUpdater(
             LockFreeIntBiMap.class,

src/dorkbox/collections/LockFreeIntMap.java

@@ -45,6 +45,8 @@ import dorkbox.collections.IntMap.*;
 @SuppressWarnings("unchecked")
 public final
 class LockFreeIntMap<V> implements Cloneable, Serializable {
+    public static final String version = Collections.version;
+
     // Recommended for best performance while adhering to the "single writer principle". Must be static-final
     private static final AtomicReferenceFieldUpdater<LockFreeIntMap, IntMap> mapREF = AtomicReferenceFieldUpdater.newUpdater(
             LockFreeIntMap.class,

src/dorkbox/collections/LockFreeIntStringMap.java

@@ -24,6 +24,8 @@ import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
 @SuppressWarnings("unchecked")
 public
 class LockFreeIntStringMap<V> {
+    public static final String version = Collections.version;
+
     private static final AtomicReferenceFieldUpdater<LockFreeIntStringMap, IntMap> mapREF = AtomicReferenceFieldUpdater.newUpdater(
             LockFreeIntStringMap.class,
             IntMap.class,

src/dorkbox/collections/LockFreeObjectIntBiMap.java

@@ -40,6 +40,8 @@ import dorkbox.collections.IntMap.*;
  */
 public
 class LockFreeObjectIntBiMap<V> {
+    public static final String version = Collections.version;
+
     // Recommended for best performance while adhering to the "single writer principle". Must be static-final
     private static final AtomicReferenceFieldUpdater<LockFreeObjectIntBiMap, ObjectIntMap> forwardREF = AtomicReferenceFieldUpdater.newUpdater(
             LockFreeObjectIntBiMap.class,

src/dorkbox/collections/LockFreeObjectIntMap.java

@@ -34,6 +34,8 @@ import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
  */
 public
 class LockFreeObjectIntMap<V> {
+    public static final String version = Collections.version;
+
     // Recommended for best performance while adhering to the "single writer principle". Must be static-final
     private static final AtomicReferenceFieldUpdater<LockFreeObjectIntMap, ObjectIntMap> mapREF = AtomicReferenceFieldUpdater.newUpdater(
             LockFreeObjectIntMap.class,

src/dorkbox/collections/LockFreeObjectMap.java

@@ -34,6 +34,8 @@ import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
 @SuppressWarnings("unchecked")
 public final
 class LockFreeObjectMap<K, V> implements Cloneable, Serializable {
+    public static final String version = Collections.version;
+
     // Recommended for best performance while adhering to the "single writer principle". Must be static-final
     private static final AtomicReferenceFieldUpdater<LockFreeObjectMap, ObjectMap> mapREF = AtomicReferenceFieldUpdater.newUpdater(
             LockFreeObjectMap.class,

src/dorkbox/collections/LockFreeSet.java

@@ -38,6 +38,8 @@ import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
 @SuppressWarnings("unchecked")
 public final
 class LockFreeSet<E> implements Set<E>, Cloneable, java.io.Serializable {
+    public static final String version = dorkbox.collections.Collections.version;
+
     // Recommended for best performance while adhering to the "single writer principle". Must be static-final
     private static final AtomicReferenceFieldUpdater<LockFreeSet, Set> setREF = AtomicReferenceFieldUpdater.newUpdater(LockFreeSet.class,
                                                                                                                        Set.class,

src/dorkbox/collections/LongArray.java

@@ -24,7 +24,9 @@ import java.util.Arrays;
  * avoids a memory copy when removing elements (the last element is moved to the removed element's position).
  * @author Nathan Sweet */
 public class LongArray {
-	public long[] items;
+    public static final String version = Collections.version;
+
+    public long[] items;
 	public int size;
 	public boolean ordered;
 
@@ -326,7 +328,7 @@ public class LongArray {
 	public void shuffle () {
 		long[] items = this.items;
 		for (int i = size - 1; i >= 0; i--) {
-			int ii = MathUtil.random(i);
+			int ii = Collections.INSTANCE.random(i);
 			long temp = items[i];
 			items[i] = items[ii];
 			items[ii] = temp;
@@ -342,7 +344,7 @@ public class LongArray {
 	/** Returns a random item from the array, or zero if the array is empty. */
 	public long random () {
 		if (size == 0) return 0;
-		return items[MathUtil.random(0,size - 1)];
+		return items[Collections.random(0, size - 1)];
 	}
 
 	public long[] toArray () {

src/dorkbox/collections/LongMap.java

@@ -30,7 +30,9 @@ import java.util.NoSuchElementException;
  * @author Nathan Sweet */
 @SuppressWarnings({"NullableProblems", "rawtypes", "unchecked"})
 public class LongMap<V> implements Iterable<LongMap.Entry<V>> {
-	private static final int PRIME1 = 0xbe1f14b1;
+    public static final String version = Collections.version;
+
+    private static final int PRIME1 = 0xbe1f14b1;
 	private static final int PRIME2 = 0xb4b82e39;
 	private static final int PRIME3 = 0xced1c241;
 	private static final int EMPTY = 0;
@@ -68,7 +70,7 @@ public class LongMap<V> implements Iterable<LongMap.Entry<V>> {
 	 * @param initialCapacity If not a power of two, it is increased to the next nearest power of two. */
 	public LongMap (int initialCapacity, float loadFactor) {
 		if (initialCapacity < 0) throw new IllegalArgumentException("initialCapacity must be >= 0: " + initialCapacity);
-		initialCapacity = MathUtil.nextPowerOfTwo((int)Math.ceil(initialCapacity / loadFactor));
+		initialCapacity = Collections.nextPowerOfTwo((int)Math.ceil(initialCapacity / loadFactor));
 		if (initialCapacity > 1 << 30) throw new IllegalArgumentException("initialCapacity is too large: " + initialCapacity);
 		capacity = initialCapacity;
 
@@ -224,7 +226,7 @@ public class LongMap<V> implements Iterable<LongMap.Entry<V>> {
 		int i = 0, pushIterations = this.pushIterations;
 		do {
 			// Replace the key and value for one of the hashes.
-			switch (MathUtil.random(2)) {
+			switch (Collections.INSTANCE.random(2)) {
 			case 0:
 				evictedKey = key1;
 				evictedValue = valueTable[index1];
@@ -412,7 +414,7 @@ public class LongMap<V> implements Iterable<LongMap.Entry<V>> {
 		if (maximumCapacity < 0) throw new IllegalArgumentException("maximumCapacity must be >= 0: " + maximumCapacity);
 		if (size > maximumCapacity) maximumCapacity = size;
 		if (capacity <= maximumCapacity) return;
-		maximumCapacity = MathUtil.nextPowerOfTwo(maximumCapacity);
+		maximumCapacity = Collections.nextPowerOfTwo(maximumCapacity);
 		resize(maximumCapacity);
 	}
 
@@ -511,7 +513,7 @@ public class LongMap<V> implements Iterable<LongMap.Entry<V>> {
 	public void ensureCapacity (int additionalCapacity) {
 		if (additionalCapacity < 0) throw new IllegalArgumentException("additionalCapacity must be >= 0: " + additionalCapacity);
 		int sizeNeeded = size + additionalCapacity;
-		if (sizeNeeded >= threshold) resize(MathUtil.nextPowerOfTwo((int)Math.ceil(sizeNeeded / loadFactor)));
+		if (sizeNeeded >= threshold) resize(Collections.nextPowerOfTwo((int)Math.ceil(sizeNeeded / loadFactor)));
 	}
 
 	private void resize (int newSize) {

src/dorkbox/collections/ObjectFloatMap.java

@@ -20,7 +20,6 @@ package dorkbox.collections;
 
 import java.util.Iterator;
 import java.util.NoSuchElementException;
-import java.util.Random;
 
 
 /** An unordered map where the values are floats. This implementation is a cuckoo hash map using 3 hashes, random walking, and a
@@ -32,7 +31,9 @@ import java.util.Random;
  * @author Nathan Sweet */
 @SuppressWarnings({"unchecked", "NullableProblems", "rawtypes"})
 public class ObjectFloatMap<K> implements Iterable<ObjectFloatMap.Entry<K>> {
-	private static final int PRIME1 = 0xbe1f14b1;
+    public static final String version = Collections.version;
+
+    private static final int PRIME1 = 0xbe1f14b1;
 	private static final int PRIME2 = 0xb4b82e39;
 	private static final int PRIME3 = 0xced1c241;
 
@@ -68,7 +69,7 @@ public class ObjectFloatMap<K> implements Iterable<ObjectFloatMap.Entry<K>> {
 	@SuppressWarnings("unchecked")
     public ObjectFloatMap (int initialCapacity, float loadFactor) {
 		if (initialCapacity < 0) throw new IllegalArgumentException("initialCapacity must be >= 0: " + initialCapacity);
-		initialCapacity = MathUtil.nextPowerOfTwo((int)Math.ceil(initialCapacity / loadFactor));
+		initialCapacity = Collections.nextPowerOfTwo((int)Math.ceil(initialCapacity / loadFactor));
 		if (initialCapacity > 1 << 30) throw new IllegalArgumentException("initialCapacity is too large: " + initialCapacity);
 		capacity = initialCapacity;
 
@@ -204,7 +205,7 @@ public class ObjectFloatMap<K> implements Iterable<ObjectFloatMap.Entry<K>> {
 		int i = 0, pushIterations = this.pushIterations;
 		do {
 			// Replace the key and value for one of the hashes.
-			switch (MathUtil.random(2)) {
+			switch (Collections.INSTANCE.random(2)) {
 			case 0:
 				evictedKey = key1;
 				evictedValue = valueTable[index1];
@@ -392,7 +393,7 @@ public class ObjectFloatMap<K> implements Iterable<ObjectFloatMap.Entry<K>> {
 		if (maximumCapacity < 0) throw new IllegalArgumentException("maximumCapacity must be >= 0: " + maximumCapacity);
 		if (size > maximumCapacity) maximumCapacity = size;
 		if (capacity <= maximumCapacity) return;
-		maximumCapacity = MathUtil.nextPowerOfTwo(maximumCapacity);
+		maximumCapacity = Collections.nextPowerOfTwo(maximumCapacity);
 		resize(maximumCapacity);
 	}
 
@@ -460,7 +461,7 @@ public class ObjectFloatMap<K> implements Iterable<ObjectFloatMap.Entry<K>> {
 	public void ensureCapacity (int additionalCapacity) {
 		if (additionalCapacity < 0) throw new IllegalArgumentException("additionalCapacity must be >= 0: " + additionalCapacity);
 		int sizeNeeded = size + additionalCapacity;
-		if (sizeNeeded >= threshold) resize(MathUtil.nextPowerOfTwo((int)Math.ceil(sizeNeeded / loadFactor)));
+		if (sizeNeeded >= threshold) resize(Collections.nextPowerOfTwo((int)Math.ceil(sizeNeeded / loadFactor)));
 	}
 
 	private void resize (int newSize) {

src/dorkbox/collections/ObjectIntMap.java

@@ -20,7 +20,6 @@ package dorkbox.collections;
 
 import java.util.Iterator;
 import java.util.NoSuchElementException;
-import java.util.Random;
 
 
 /** An unordered map where the values are ints. This implementation is a cuckoo hash map using 3 hashes, random walking, and a
@@ -32,6 +31,8 @@ import java.util.Random;
  * @author Nathan Sweet */
 @SuppressWarnings({"unchecked", "NullableProblems"})
 public class ObjectIntMap<K> implements Iterable<ObjectIntMap.Entry<K>> {
+    public static final String version = Collections.version;
+
     private static final int PRIME1 = 0xbe1f14b1;
     private static final int PRIME2 = 0xb4b82e39;
     private static final int PRIME3 = 0xced1c241;
@@ -67,7 +68,7 @@ public class ObjectIntMap<K> implements Iterable<ObjectIntMap.Entry<K>> {
      * @param initialCapacity If not a power of two, it is increased to the next nearest power of two. */
     public ObjectIntMap (int initialCapacity, float loadFactor) {
         if (initialCapacity < 0) throw new IllegalArgumentException("initialCapacity must be >= 0: " + initialCapacity);
-        initialCapacity = MathUtil.nextPowerOfTwo((int)Math.ceil(initialCapacity / loadFactor));
+        initialCapacity = Collections.nextPowerOfTwo((int)Math.ceil(initialCapacity / loadFactor));
         if (initialCapacity > 1 << 30) throw new IllegalArgumentException("initialCapacity is too large: " + initialCapacity);
         capacity = initialCapacity;
 
@@ -203,7 +204,7 @@ public class ObjectIntMap<K> implements Iterable<ObjectIntMap.Entry<K>> {
         int i = 0, pushIterations = this.pushIterations;
         do {
             // Replace the key and value for one of the hashes.
-            switch (MathUtil.random(2)) {
+            switch (Collections.INSTANCE.random(2)) {
                 case 0:
                     evictedKey = key1;
                     evictedValue = valueTable[index1];
@@ -391,7 +392,7 @@ public class ObjectIntMap<K> implements Iterable<ObjectIntMap.Entry<K>> {
         if (maximumCapacity < 0) throw new IllegalArgumentException("maximumCapacity must be >= 0: " + maximumCapacity);
         if (size > maximumCapacity) maximumCapacity = size;
         if (capacity <= maximumCapacity) return;
-        maximumCapacity = MathUtil.nextPowerOfTwo(maximumCapacity);
+        maximumCapacity = Collections.nextPowerOfTwo(maximumCapacity);
         resize(maximumCapacity);
     }
 
@@ -460,7 +461,7 @@ public class ObjectIntMap<K> implements Iterable<ObjectIntMap.Entry<K>> {
     public void ensureCapacity (int additionalCapacity) {
         if (additionalCapacity < 0) throw new IllegalArgumentException("additionalCapacity must be >= 0: " + additionalCapacity);
         int sizeNeeded = size + additionalCapacity;
-        if (sizeNeeded >= threshold) resize(MathUtil.nextPowerOfTwo((int)Math.ceil(sizeNeeded / loadFactor)));
+        if (sizeNeeded >= threshold) resize(Collections.nextPowerOfTwo((int)Math.ceil(sizeNeeded / loadFactor)));
     }
 
     private void resize (int newSize) {

src/dorkbox/collections/ObjectMap.java

@@ -20,7 +20,6 @@ package dorkbox.collections;
 
 import java.util.Iterator;
 import java.util.NoSuchElementException;
-import java.util.Random;
 
 /** An unordered map. This implementation is a cuckoo hash map using 3 hashes, random walking, and a small stash for problematic
  * keys. Null keys are not allowed. Null values are allowed. No allocation is done except when growing the table size. <br>
@@ -34,7 +33,9 @@ import java.util.Random;
  * @author Nathan Sweet */
 @SuppressWarnings("unchecked")
 public class ObjectMap<K, V> implements Iterable<ObjectMap.Entry<K, V>> {
-	private static final int PRIME1 = 0xbe1f14b1;
+    public static final String version = Collections.version;
+
+    private static final int PRIME1 = 0xbe1f14b1;
 	private static final int PRIME2 = 0xb4b82e39;
 	private static final int PRIME3 = 0xced1c241;
 
@@ -69,7 +70,7 @@ public class ObjectMap<K, V> implements Iterable<ObjectMap.Entry<K, V>> {
 	 * @param initialCapacity If not a power of two, it is increased to the next nearest power of two. */
 	public ObjectMap (int initialCapacity, float loadFactor) {
 		if (initialCapacity < 0) throw new IllegalArgumentException("initialCapacity must be >= 0: " + initialCapacity);
-		initialCapacity = MathUtil.nextPowerOfTwo((int)Math.ceil(initialCapacity / loadFactor));
+		initialCapacity = Collections.nextPowerOfTwo((int)Math.ceil(initialCapacity / loadFactor));
 		if (initialCapacity > 1 << 30) throw new IllegalArgumentException("initialCapacity is too large: " + initialCapacity);
 		capacity = initialCapacity;
 
@@ -212,7 +213,7 @@ public class ObjectMap<K, V> implements Iterable<ObjectMap.Entry<K, V>> {
 		int i = 0, pushIterations = this.pushIterations;
 		do {
 			// Replace the key and value for one of the hashes.
-			switch (MathUtil.random.nextInt(2)) {
+			switch (Collections.INSTANCE.random(2)) {
 			case 0:
 				evictedKey = key1;
 				evictedValue = valueTable[index1];
@@ -393,7 +394,7 @@ public class ObjectMap<K, V> implements Iterable<ObjectMap.Entry<K, V>> {
 		if (maximumCapacity < 0) throw new IllegalArgumentException("maximumCapacity must be >= 0: " + maximumCapacity);
 		if (size > maximumCapacity) maximumCapacity = size;
 		if (capacity <= maximumCapacity) return;
-		maximumCapacity = MathUtil.nextPowerOfTwo(maximumCapacity);
+		maximumCapacity = Collections.nextPowerOfTwo(maximumCapacity);
 		resize(maximumCapacity);
 	}
 
@@ -487,7 +488,7 @@ public class ObjectMap<K, V> implements Iterable<ObjectMap.Entry<K, V>> {
 	public void ensureCapacity (int additionalCapacity) {
 		if (additionalCapacity < 0) throw new IllegalArgumentException("additionalCapacity must be >= 0: " + additionalCapacity);
 		int sizeNeeded = size + additionalCapacity;
-		if (sizeNeeded >= threshold) resize(MathUtil.nextPowerOfTwo((int)Math.ceil(sizeNeeded / loadFactor)));
+		if (sizeNeeded >= threshold) resize(Collections.nextPowerOfTwo((int)Math.ceil(sizeNeeded / loadFactor)));
 	}
 
 	private void resize (int newSize) {

src/dorkbox/collections/ObjectSet.java

@@ -20,7 +20,6 @@ package dorkbox.collections;
 
 import java.util.Iterator;
 import java.util.NoSuchElementException;
-import java.util.Random;
 
 
 /** An unordered set where the keys are objects. This implementation uses cuckoo hashing using 3 hashes, random walking, and a
@@ -35,7 +34,9 @@ import java.util.Random;
  * @author Nathan Sweet */
 @SuppressWarnings({"unchecked", "rawtypes", "NullableProblems", "SuspiciousSystemArraycopy"})
 public class ObjectSet<T> implements Iterable<T> {
-	private static final int PRIME1 = 0xbe1f14b1;
+    public static final String version = Collections.version;
+
+    private static final int PRIME1 = 0xbe1f14b1;
 	private static final int PRIME2 = 0xb4b82e39;
 	private static final int PRIME3 = 0xced1c241;
 
@@ -67,7 +68,7 @@ public class ObjectSet<T> implements Iterable<T> {
 	 * @param initialCapacity If not a power of two, it is increased to the next nearest power of two. */
 	public ObjectSet (int initialCapacity, float loadFactor) {
 		if (initialCapacity < 0) throw new IllegalArgumentException("initialCapacity must be >= 0: " + initialCapacity);
-		initialCapacity = MathUtil.nextPowerOfTwo((int)Math.ceil(initialCapacity / loadFactor));
+		initialCapacity = Collections.nextPowerOfTwo((int)Math.ceil(initialCapacity / loadFactor));
 		if (initialCapacity > 1 << 30) throw new IllegalArgumentException("initialCapacity is too large: " + initialCapacity);
 		capacity = initialCapacity;
 
@@ -204,7 +205,7 @@ public class ObjectSet<T> implements Iterable<T> {
 		int i = 0, pushIterations = this.pushIterations;
 		do {
 			// Replace the key and value for one of the hashes.
-			switch (MathUtil.random.nextInt(2)) {
+			switch (Collections.INSTANCE.random(2)) {
 			case 0:
 				evictedKey = key1;
 				keyTable[index1] = insertKey;
@@ -327,7 +328,7 @@ public class ObjectSet<T> implements Iterable<T> {
 		if (maximumCapacity < 0) throw new IllegalArgumentException("maximumCapacity must be >= 0: " + maximumCapacity);
 		if (size > maximumCapacity) maximumCapacity = size;
 		if (capacity <= maximumCapacity) return;
-		maximumCapacity = MathUtil.nextPowerOfTwo(maximumCapacity);
+		maximumCapacity = Collections.nextPowerOfTwo(maximumCapacity);
 		resize(maximumCapacity);
 	}
 
@@ -402,7 +403,7 @@ public class ObjectSet<T> implements Iterable<T> {
 	public void ensureCapacity (int additionalCapacity) {
 		if (additionalCapacity < 0) throw new IllegalArgumentException("additionalCapacity must be >= 0: " + additionalCapacity);
 		int sizeNeeded = size + additionalCapacity;
-		if (sizeNeeded >= threshold) resize(MathUtil.nextPowerOfTwo((int)Math.ceil(sizeNeeded / loadFactor)));
+		if (sizeNeeded >= threshold) resize(Collections.nextPowerOfTwo((int)Math.ceil(sizeNeeded / loadFactor)));
 	}
 
 	private void resize (int newSize) {

src/dorkbox/collections/OrderedMap.java

@@ -28,7 +28,9 @@ import java.util.NoSuchElementException;
  * @author Nathan Sweet */
 @SuppressWarnings({"unchecked", "NullableProblems"})
 public class OrderedMap<K, V> extends ObjectMap<K, V> {
-	final Array<K> keys;
+    public static final String version = Collections.version;
+
+    final Array<K> keys;
 
 	private Entries entries1, entries2;
 	private Values values1, values2;

src/dorkbox/collections/OrderedSet.java

@@ -28,7 +28,9 @@ import java.util.NoSuchElementException;
  * @author Nathan Sweet */
 @SuppressWarnings({"unchecked", "rawtypes"})
 public class OrderedSet<T> extends ObjectSet<T> {
-	final Array<T> items;
+    public static final String version = Collections.version;
+
+    final Array<T> items;
 	OrderedSetIterator iterator1, iterator2;
 
 	public OrderedSet () {

src/dorkbox/collections/QuickSelect.java

@@ -25,7 +25,9 @@ import java.util.Comparator;
  * http://en.wikipedia.org/wiki/Quickselect
  * @author Jon Renner */
 public class QuickSelect<T> {
-	private T[] array;
+    public static final String version = Collections.version;
+
+    private T[] array;
 	private Comparator<? super T> comp;
 
 	public int select (T[] items, Comparator<T> comp, int n, int size) {

src/dorkbox/collections/Select.java

@@ -34,7 +34,9 @@ import java.util.Comparator;
  * @author Jon Renner */
 @SuppressWarnings("unchecked")
 public class Select {
-	private static Select instance;
+    public static final String version = Collections.version;
+
+    private static Select instance;
 	private QuickSelect quickSelect;
 
 	/** Provided for convenience */

src/dorkbox/collections/Sort.java

@@ -23,7 +23,9 @@ import java.util.Comparator;
  * @author Nathan Sweet */
 @SuppressWarnings({"RedundantCast", "unchecked", "rawtypes"})
 public class Sort {
-	static private Sort instance;
+    public static final String version = Collections.version;
+
+    static private Sort instance;
 
 	private TimSort timSort;
 	private ComparableTimSort comparableTimSort;

src/dorkbox/collections/TimSort.java

@@ -39,7 +39,9 @@ import java.util.Comparator;
  * in place, using a binary insertion sort. */
 @SuppressWarnings("unchecked")
 class TimSort<T> {
-	/** This is the minimum sized sequence that will be merged. Shorter sequences will be lengthened by calling binarySort. If the
+    public static final String version = Collections.version;
+
+    /** This is the minimum sized sequence that will be merged. Shorter sequences will be lengthened by calling binarySort. If the
 	 * entire array is less than this length, no merges will be performed.
 	 *
 	 * This constant should be a power of two. It was 64 in Tim Peter's C implementation, but 32 was empirically determined to work