Cleanup

12 files changed, 303 insertions, 375 deletions

diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcdata/ExtendedMap.java b/BJC-Utils2/src/main/java/bjc/utils/funcdata/ExtendedMap.java
index caa487c..909c5e9 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/funcdata/ExtendedMap.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/funcdata/ExtendedMap.java
@@ -1,17 +1,17 @@
 package bjc.utils.funcdata;
 
-import bjc.utils.funcutils.ListUtils;
-
 import java.util.function.BiConsumer;
 import java.util.function.Consumer;
 import java.util.function.Function;
 
+import bjc.utils.funcutils.ListUtils;
+
 class ExtendedMap<KeyType, ValueType> implements IMap<KeyType, ValueType> {
-	private IMap<KeyType, ValueType> delegate;
+	private final IMap<KeyType, ValueType> delegate;
 
-	private IMap<KeyType, ValueType> store;
+	private final IMap<KeyType, ValueType> store;
 
-	public ExtendedMap(IMap<KeyType, ValueType> delegate, IMap<KeyType, ValueType> store) {
+	public ExtendedMap(final IMap<KeyType, ValueType> delegate, final IMap<KeyType, ValueType> store) {
 		this.delegate = delegate;
 		this.store = store;
 	}
@@ -22,9 +22,8 @@ class ExtendedMap<KeyType, ValueType> implements IMap<KeyType, ValueType> {
 	}
 
 	@Override
-	public boolean containsKey(KeyType key) {
-		if (store.containsKey(key))
-			return true;
+	public boolean containsKey(final KeyType key) {
+		if (store.containsKey(key)) return true;
 
 		return delegate.containsKey(key);
 	}
@@ -35,30 +34,29 @@ class ExtendedMap<KeyType, ValueType> implements IMap<KeyType, ValueType> {
 	}
 
 	@Override
-	public void forEach(BiConsumer<KeyType, ValueType> action) {
+	public void forEach(final BiConsumer<KeyType, ValueType> action) {
 		store.forEach(action);
 
 		delegate.forEach(action);
 	}
 
 	@Override
-	public void forEachKey(Consumer<KeyType> action) {
+	public void forEachKey(final Consumer<KeyType> action) {
 		store.forEachKey(action);
 
 		delegate.forEachKey(action);
 	}
 
 	@Override
-	public void forEachValue(Consumer<ValueType> action) {
+	public void forEachValue(final Consumer<ValueType> action) {
 		store.forEachValue(action);
 
 		delegate.forEachValue(action);
 	}
 
 	@Override
-	public ValueType get(KeyType key) {
-		if (store.containsKey(key))
-			return store.get(key);
+	public ValueType get(final KeyType key) {
+		if (store.containsKey(key)) return store.get(key);
 
 		return delegate.get(key);
 	}
@@ -74,19 +72,18 @@ class ExtendedMap<KeyType, ValueType> implements IMap<KeyType, ValueType> {
 	}
 
 	@Override
-	public <MappedValue> IMap<KeyType, MappedValue> transform(Function<ValueType, MappedValue> transformer) {
+	public <MappedValue> IMap<KeyType, MappedValue> transform(final Function<ValueType, MappedValue> transformer) {
 		return new TransformedValueMap<>(this, transformer);
 	}
 
 	@Override
-	public ValueType put(KeyType key, ValueType val) {
+	public ValueType put(final KeyType key, final ValueType val) {
 		return store.put(key, val);
 	}
 
 	@Override
-	public ValueType remove(KeyType key) {
-		if (!store.containsKey(key))
-			return delegate.remove(key);
+	public ValueType remove(final KeyType key) {
+		if (!store.containsKey(key)) return delegate.remove(key);
 
 		return store.remove(key);
 	}
@@ -100,32 +97,25 @@ class ExtendedMap<KeyType, ValueType> implements IMap<KeyType, ValueType> {
 	public int hashCode() {
 		final int prime = 31;
 		int result = 1;
-		result = prime * result + ((delegate == null) ? 0 : delegate.hashCode());
-		result = prime * result + ((store == null) ? 0 : store.hashCode());
+		result = prime * result + (delegate == null ? 0 : delegate.hashCode());
+		result = prime * result + (store == null ? 0 : store.hashCode());
 		return result;
 	}
 
 	@Override
-	public boolean equals(Object obj) {
-		if (this == obj)
-			return true;
-		if (obj == null)
-			return false;
-		if (!(obj instanceof ExtendedMap))
-			return false;
+	public boolean equals(final Object obj) {
+		if (this == obj) return true;
+		if (obj == null) return false;
+		if (!(obj instanceof ExtendedMap)) return false;
 
-		ExtendedMap<?, ?> other = (ExtendedMap<?, ?>) obj;
+		final ExtendedMap<?, ?> other = (ExtendedMap<?, ?>) obj;
 
 		if (delegate == null) {
-			if (other.delegate != null)
-				return false;
-		} else if (!delegate.equals(other.delegate))
-			return false;
+			if (other.delegate != null) return false;
+		} else if (!delegate.equals(other.delegate)) return false;
 		if (store == null) {
-			if (other.store != null)
-				return false;
-		} else if (!store.equals(other.store))
-			return false;
+			if (other.store != null) return false;
+		} else if (!store.equals(other.store)) return false;
 
 		return true;
 	}
diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcdata/FunctionalList.java b/BJC-Utils2/src/main/java/bjc/utils/funcdata/FunctionalList.java
index 7627bdf..55ea7ff 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/funcdata/FunctionalList.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/funcdata/FunctionalList.java
@@ -1,10 +1,5 @@
 package bjc.utils.funcdata;
 
-import bjc.utils.data.IHolder;
-import bjc.utils.data.IPair;
-import bjc.utils.data.Identity;
-import bjc.utils.data.Pair;
-
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Comparator;
@@ -17,6 +12,11 @@ import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.function.Predicate;
 
+import bjc.utils.data.IHolder;
+import bjc.utils.data.IPair;
+import bjc.utils.data.Identity;
+import bjc.utils.data.Pair;
+
 /**
  * A wrapper over another list that provides eager functional operations over
  * it.
@@ -33,7 +33,7 @@ public class FunctionalList<E> implements Cloneable, IList<E> {
 	/*
 	 * The list used as a backing store
 	 */
-	private List<E> wrapped;
+	private final List<E> wrapped;
 
 	/**
 	 * Create a new empty functional list.
@@ -51,10 +51,10 @@ public class FunctionalList<E> implements Cloneable, IList<E> {
 	 *                The items to put into this functional list.
 	 */
 	@SafeVarargs
-	public FunctionalList(E... items) {
+	public FunctionalList(final E... items) {
 		wrapped = new ArrayList<>(items.length);
 
-		for (E item : items) {
+		for (final E item : items) {
 			wrapped.add(item);
 		}
 	}
@@ -65,7 +65,7 @@ public class FunctionalList<E> implements Cloneable, IList<E> {
 	 * @param size
 	 *                The size of the backing list .
 	 */
-	private FunctionalList(int size) {
+	private FunctionalList(final int size) {
 		wrapped = new ArrayList<>(size);
 	}
 
@@ -77,24 +77,22 @@ public class FunctionalList<E> implements Cloneable, IList<E> {
 	 * @param backing
 	 *                The list to use as a backing list.
 	 */
-	public FunctionalList(List<E> backing) {
-		if (backing == null)
-			throw new NullPointerException("Backing list must be non-null");
+	public FunctionalList(final List<E> backing) {
+		if (backing == null) throw new NullPointerException("Backing list must be non-null");
 
 		wrapped = backing;
 	}
 
 	@Override
-	public boolean add(E item) {
+	public boolean add(final E item) {
 		return wrapped.add(item);
 	}
 
 	@Override
-	public boolean allMatch(Predicate<E> predicate) {
-		if (predicate == null)
-			throw new NullPointerException("Predicate must be non-null");
+	public boolean allMatch(final Predicate<E> predicate) {
+		if (predicate == null) throw new NullPointerException("Predicate must be non-null");
 
-		for (E item : wrapped) {
+		for (final E item : wrapped) {
 			if (!predicate.test(item))
 				// We've found a non-matching item
 				return false;
@@ -105,11 +103,10 @@ public class FunctionalList<E> implements Cloneable, IList<E> {
 	}
 
 	@Override
-	public boolean anyMatch(Predicate<E> predicate) {
-		if (predicate == null)
-			throw new NullPointerException("Predicate must be not null");
+	public boolean anyMatch(final Predicate<E> predicate) {
+		if (predicate == null) throw new NullPointerException("Predicate must be not null");
 
-		for (E item : wrapped) {
+		for (final E item : wrapped) {
 			if (predicate.test(item))
 				// We've found a matching item
 				return true;
@@ -128,9 +125,9 @@ public class FunctionalList<E> implements Cloneable, IList<E> {
 	 */
 	@Override
 	public IList<E> clone() {
-		IList<E> cloned = new FunctionalList<>();
+		final IList<E> cloned = new FunctionalList<>();
 
-		for (E element : wrapped) {
+		for (final E element : wrapped) {
 			cloned.add(element);
 		}
 
@@ -138,22 +135,21 @@ public class FunctionalList<E> implements Cloneable, IList<E> {
 	}
 
 	@Override
-	public <T, F> IList<F> combineWith(IList<T> rightList, BiFunction<E, T, F> itemCombiner) {
+	public <T, F> IList<F> combineWith(final IList<T> rightList, final BiFunction<E, T, F> itemCombiner) {
 		if (rightList == null)
 			throw new NullPointerException("Target combine list must not be null");
-		else if (itemCombiner == null)
-			throw new NullPointerException("Combiner must not be null");
+		else if (itemCombiner == null) throw new NullPointerException("Combiner must not be null");
 
-		IList<F> returned = new FunctionalList<>();
+		final IList<F> returned = new FunctionalList<>();
 
 		// Get the iterator for the other list
-		Iterator<T> rightIterator = rightList.toIterable().iterator();
+		final Iterator<T> rightIterator = rightList.toIterable().iterator();
 
-		for (Iterator<E> leftIterator = wrapped.iterator(); leftIterator.hasNext()
+		for (final Iterator<E> leftIterator = wrapped.iterator(); leftIterator.hasNext()
 				&& rightIterator.hasNext();) {
 			// Add the transformed items to the result list
-			E leftVal = leftIterator.next();
-			T rightVal = rightIterator.next();
+			final E leftVal = leftIterator.next();
+			final T rightVal = rightIterator.next();
 
 			returned.add(itemCombiner.apply(leftVal, rightVal));
 		}
@@ -162,7 +158,7 @@ public class FunctionalList<E> implements Cloneable, IList<E> {
 	}
 
 	@Override
-	public boolean contains(E item) {
+	public boolean contains(final E item) {
 		// Check if any items in the list match the provided item
 		return this.anyMatch(item::equals);
 	}
@@ -176,17 +172,15 @@ public class FunctionalList<E> implements Cloneable, IList<E> {
 	}
 
 	@Override
-	public <T> IList<T> flatMap(Function<E, IList<T>> expander) {
-		if (expander == null)
-			throw new NullPointerException("Expander must not be null");
+	public <T> IList<T> flatMap(final Function<E, IList<T>> expander) {
+		if (expander == null) throw new NullPointerException("Expander must not be null");
 
-		IList<T> returned = new FunctionalList<>(this.wrapped.size());
+		final IList<T> returned = new FunctionalList<>(this.wrapped.size());
 
 		forEach(element -> {
-			IList<T> expandedElement = expander.apply(element);
+			final IList<T> expandedElement = expander.apply(element);
 
-			if (expandedElement == null)
-				throw new NullPointerException("Expander returned null list");
+			if (expandedElement == null) throw new NullPointerException("Expander returned null list");
 
 			// Add each element to the returned list
 			expandedElement.forEach(returned::add);
@@ -196,21 +190,19 @@ public class FunctionalList<E> implements Cloneable, IList<E> {
 	}
 
 	@Override
-	public void forEach(Consumer<? super E> action) {
-		if (action == null)
-			throw new NullPointerException("Action is null");
+	public void forEach(final Consumer<? super E> action) {
+		if (action == null) throw new NullPointerException("Action is null");
 
 		wrapped.forEach(action);
 	}
 
 	@Override
-	public void forEachIndexed(BiConsumer<Integer, E> indexedAction) {
-		if (indexedAction == null)
-			throw new NullPointerException("Action must not be null");
+	public void forEachIndexed(final BiConsumer<Integer, E> indexedAction) {
+		if (indexedAction == null) throw new NullPointerException("Action must not be null");
 
 		// This is held b/c ref'd variables must be final/effectively
 		// final
-		IHolder<Integer> currentIndex = new Identity<>(0);
+		final IHolder<Integer> currentIndex = new Identity<>(0);
 
 		wrapped.forEach((element) -> {
 			// Call the action with the index and the value
@@ -222,7 +214,7 @@ public class FunctionalList<E> implements Cloneable, IList<E> {
 	}
 
 	@Override
-	public E getByIndex(int index) {
+	public E getByIndex(final int index) {
 		return wrapped.get(index);
 	}
 
@@ -236,11 +228,10 @@ public class FunctionalList<E> implements Cloneable, IList<E> {
 	}
 
 	@Override
-	public IList<E> getMatching(Predicate<E> predicate) {
-		if (predicate == null)
-			throw new NullPointerException("Predicate must not be null");
+	public IList<E> getMatching(final Predicate<E> predicate) {
+		if (predicate == null) throw new NullPointerException("Predicate must not be null");
 
-		IList<E> returned = new FunctionalList<>();
+		final IList<E> returned = new FunctionalList<>();
 
 		wrapped.forEach((element) -> {
 			if (predicate.test(element)) {
@@ -266,16 +257,15 @@ public class FunctionalList<E> implements Cloneable, IList<E> {
 	/*
 	 * Check if a partition has room for another item
 	 */
-	private Boolean isPartitionFull(int numberPerPartition, IHolder<IList<E>> currentPartition) {
+	private Boolean isPartitionFull(final int numberPerPartition, final IHolder<IList<E>> currentPartition) {
 		return currentPartition.unwrap((partition) -> partition.getSize() >= numberPerPartition);
 	}
 
 	@Override
-	public <T> IList<T> map(Function<E, T> elementTransformer) {
-		if (elementTransformer == null)
-			throw new NullPointerException("Transformer must be not null");
+	public <T> IList<T> map(final Function<E, T> elementTransformer) {
+		if (elementTransformer == null) throw new NullPointerException("Transformer must be not null");
 
-		IList<T> returned = new FunctionalList<>(this.wrapped.size());
+		final IList<T> returned = new FunctionalList<>(this.wrapped.size());
 
 		forEach(element -> {
 			// Add the transformed item to the result
@@ -286,23 +276,23 @@ public class FunctionalList<E> implements Cloneable, IList<E> {
 	}
 
 	@Override
-	public <T> IList<IPair<E, T>> pairWith(IList<T> rightList) {
+	public <T> IList<IPair<E, T>> pairWith(final IList<T> rightList) {
 		return combineWith(rightList, Pair<E, T>::new);
 	}
 
 	@Override
-	public IList<IList<E>> partition(int numberPerPartition) {
+	public IList<IList<E>> partition(final int numberPerPartition) {
 		if (numberPerPartition < 1 || numberPerPartition > wrapped.size()) {
-			String fmt = "%s is an invalid partition size. Must be between 1 and %d";
-			String msg = String.format(fmt, numberPerPartition, wrapped.size());
+			final String fmt = "%s is an invalid partition size. Must be between 1 and %d";
+			final String msg = String.format(fmt, numberPerPartition, wrapped.size());
 
 			throw new IllegalArgumentException(msg);
 		}
 
-		IList<IList<E>> returned = new FunctionalList<>();
+		final IList<IList<E>> returned = new FunctionalList<>();
 
 		// The current partition being filled
-		IHolder<IList<E>> currentPartition = new Identity<>(new FunctionalList<>());
+		final IHolder<IList<E>> currentPartition = new Identity<>(new FunctionalList<>());
 
 		this.forEach(element -> {
 			if (isPartitionFull(numberPerPartition, currentPartition)) {
@@ -321,30 +311,28 @@ public class FunctionalList<E> implements Cloneable, IList<E> {
 	}
 
 	@Override
-	public void prepend(E item) {
+	public void prepend(final E item) {
 		wrapped.add(0, item);
 	}
 
 	@Override
-	public E randItem(Function<Integer, Integer> rnd) {
-		if (rnd == null)
-			throw new NullPointerException("Random source must not be null");
+	public E randItem(final Function<Integer, Integer> rnd) {
+		if (rnd == null) throw new NullPointerException("Random source must not be null");
 
-		int randomIndex = rnd.apply(wrapped.size());
+		final int randomIndex = rnd.apply(wrapped.size());
 
 		return wrapped.get(randomIndex);
 	}
 
 	@Override
-	public <T, F> F reduceAux(T initialValue, BiFunction<E, T, T> stateAccumulator,
-			Function<T, F> resultTransformer) {
+	public <T, F> F reduceAux(final T initialValue, final BiFunction<E, T, T> stateAccumulator,
+			final Function<T, F> resultTransformer) {
 		if (stateAccumulator == null)
 			throw new NullPointerException("Accumulator must not be null");
-		else if (resultTransformer == null)
-			throw new NullPointerException("Transformer must not be null");
+		else if (resultTransformer == null) throw new NullPointerException("Transformer must not be null");
 
 		// The current collapsed list
-		IHolder<T> currentState = new Identity<>(initialValue);
+		final IHolder<T> currentState = new Identity<>(initialValue);
 
 		wrapped.forEach(element -> {
 			// Accumulate a new value into the state
@@ -356,15 +344,14 @@ public class FunctionalList<E> implements Cloneable, IList<E> {
 	}
 
 	@Override
-	public boolean removeIf(Predicate<E> removePredicate) {
-		if (removePredicate == null)
-			throw new NullPointerException("Predicate must be non-null");
+	public boolean removeIf(final Predicate<E> removePredicate) {
+		if (removePredicate == null) throw new NullPointerException("Predicate must be non-null");
 
 		return wrapped.removeIf(removePredicate);
 	}
 
 	@Override
-	public void removeMatching(E desiredElement) {
+	public void removeMatching(final E desiredElement) {
 		removeIf(element -> element.equals(desiredElement));
 	}
 
@@ -374,9 +361,9 @@ public class FunctionalList<E> implements Cloneable, IList<E> {
 	}
 
 	@Override
-	public E search(E searchKey, Comparator<E> comparator) {
+	public E search(final E searchKey, final Comparator<E> comparator) {
 		// Search our internal list
-		int foundIndex = Collections.binarySearch(wrapped, searchKey, comparator);
+		final int foundIndex = Collections.binarySearch(wrapped, searchKey, comparator);
 
 		if (foundIndex >= 0) // We found a matching element
 			return wrapped.get(foundIndex);
@@ -386,7 +373,7 @@ public class FunctionalList<E> implements Cloneable, IList<E> {
 	}
 
 	@Override
-	public void sort(Comparator<E> comparator) {
+	public void sort(final Comparator<E> comparator) {
 		// sb.deleteCharAt(sb.length() - 2);
 		Collections.sort(wrapped, comparator);
 	}
@@ -397,7 +384,7 @@ public class FunctionalList<E> implements Cloneable, IList<E> {
 	}
 
 	@Override
-	public E[] toArray(E[] arrType) {
+	public E[] toArray(final E[] arrType) {
 		return wrapped.toArray(arrType);
 	}
 
@@ -408,20 +395,18 @@ public class FunctionalList<E> implements Cloneable, IList<E> {
 
 	@Override
 	public String toString() {
-		int lSize = getSize();
+		final int lSize = getSize();
 
-		if (lSize == 0)
-			return "()";
+		if (lSize == 0) return "()";
 
-		StringBuilder sb = new StringBuilder("(");
-		Iterator<E> itr = toIterable().iterator();
-		E itm = itr.next();
+		final StringBuilder sb = new StringBuilder("(");
+		final Iterator<E> itr = toIterable().iterator();
+		final E itm = itr.next();
 		int i = 0;
 
-		if (lSize == 1)
-			return "(" + itm + ")";
+		if (lSize == 1) return "(" + itm + ")";
 
-		for (E item : toIterable()) {
+		for (final E item : toIterable()) {
 			sb.append(item.toString());
 
 			if (i < lSize - 1) {
diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcdata/FunctionalMap.java b/BJC-Utils2/src/main/java/bjc/utils/funcdata/FunctionalMap.java
index 62c39af..c4f0ff1 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/funcdata/FunctionalMap.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/funcdata/FunctionalMap.java
@@ -1,13 +1,13 @@
 package bjc.utils.funcdata;
 
-import bjc.utils.data.IPair;
-
 import java.util.HashMap;
 import java.util.Map;
 import java.util.function.BiConsumer;
 import java.util.function.Consumer;
 import java.util.function.Function;
 
+import bjc.utils.data.IPair;
+
 /**
  * Basic implementation of {@link IMap}
  *
@@ -35,10 +35,10 @@ public class FunctionalMap<KeyType, ValueType> implements IMap<KeyType, ValueTyp
 	 *                The entries to put into the map
 	 */
 	@SafeVarargs
-	public FunctionalMap(IPair<KeyType, ValueType>... entries) {
+	public FunctionalMap(final IPair<KeyType, ValueType>... entries) {
 		this();
 
-		for (IPair<KeyType, ValueType> entry : entries) {
+		for (final IPair<KeyType, ValueType> entry : entries) {
 			entry.doWith((key, val) -> {
 				wrappedMap.put(key, val);
 			});
@@ -51,9 +51,8 @@ public class FunctionalMap<KeyType, ValueType> implements IMap<KeyType, ValueTyp
 	 * @param wrap
 	 *                The map to wrap
 	 */
-	public FunctionalMap(Map<KeyType, ValueType> wrap) {
-		if (wrap == null)
-			throw new NullPointerException("Map to wrap must not be null");
+	public FunctionalMap(final Map<KeyType, ValueType> wrap) {
+		if (wrap == null) throw new NullPointerException("Map to wrap must not be null");
 
 		wrappedMap = wrap;
 	}
@@ -64,7 +63,7 @@ public class FunctionalMap<KeyType, ValueType> implements IMap<KeyType, ValueTyp
 	}
 
 	@Override
-	public boolean containsKey(KeyType key) {
+	public boolean containsKey(final KeyType key) {
 		return wrappedMap.containsKey(key);
 	}
 
@@ -74,27 +73,26 @@ public class FunctionalMap<KeyType, ValueType> implements IMap<KeyType, ValueTyp
 	}
 
 	@Override
-	public void forEach(BiConsumer<KeyType, ValueType> action) {
+	public void forEach(final BiConsumer<KeyType, ValueType> action) {
 		wrappedMap.forEach(action);
 	}
 
 	@Override
-	public void forEachKey(Consumer<KeyType> action) {
+	public void forEachKey(final Consumer<KeyType> action) {
 		wrappedMap.keySet().forEach(action);
 	}
 
 	@Override
-	public void forEachValue(Consumer<ValueType> action) {
+	public void forEachValue(final Consumer<ValueType> action) {
 		wrappedMap.values().forEach(action);
 	}
 
 	@Override
-	public ValueType get(KeyType key) {
-		if (key == null)
-			throw new NullPointerException("Key must not be null");
+	public ValueType get(final KeyType key) {
+		if (key == null) throw new NullPointerException("Key must not be null");
 
 		if (!wrappedMap.containsKey(key)) {
-			String msg = String.format("Key %s is not present in the map", key);
+			final String msg = String.format("Key %s is not present in the map", key);
 
 			throw new IllegalArgumentException(msg);
 		}
@@ -109,7 +107,7 @@ public class FunctionalMap<KeyType, ValueType> implements IMap<KeyType, ValueTyp
 
 	@Override
 	public IList<KeyType> keyList() {
-		FunctionalList<KeyType> keys = new FunctionalList<>();
+		final FunctionalList<KeyType> keys = new FunctionalList<>();
 
 		wrappedMap.keySet().forEach(key -> {
 			keys.add(key);
@@ -119,23 +117,21 @@ public class FunctionalMap<KeyType, ValueType> implements IMap<KeyType, ValueTyp
 	}
 
 	@Override
-	public <MappedValue> IMap<KeyType, MappedValue> transform(Function<ValueType, MappedValue> transformer) {
-		if (transformer == null)
-			throw new NullPointerException("Transformer must not be null");
+	public <MappedValue> IMap<KeyType, MappedValue> transform(final Function<ValueType, MappedValue> transformer) {
+		if (transformer == null) throw new NullPointerException("Transformer must not be null");
 
 		return new TransformedValueMap<>(this, transformer);
 	}
 
 	@Override
-	public ValueType put(KeyType key, ValueType val) {
-		if (key == null)
-			throw new NullPointerException("Key must not be null");
+	public ValueType put(final KeyType key, final ValueType val) {
+		if (key == null) throw new NullPointerException("Key must not be null");
 
 		return wrappedMap.put(key, val);
 	}
 
 	@Override
-	public ValueType remove(KeyType key) {
+	public ValueType remove(final KeyType key) {
 		return wrappedMap.remove(key);
 	}
 
@@ -146,7 +142,7 @@ public class FunctionalMap<KeyType, ValueType> implements IMap<KeyType, ValueTyp
 
 	@Override
 	public IList<ValueType> valueList() {
-		FunctionalList<ValueType> values = new FunctionalList<>();
+		final FunctionalList<ValueType> values = new FunctionalList<>();
 
 		wrappedMap.values().forEach(value -> {
 			values.add(value);
@@ -159,26 +155,21 @@ public class FunctionalMap<KeyType, ValueType> implements IMap<KeyType, ValueTyp
 	public int hashCode() {
 		final int prime = 31;
 		int result = 1;
-		result = prime * result + ((wrappedMap == null) ? 0 : wrappedMap.hashCode());
+		result = prime * result + (wrappedMap == null ? 0 : wrappedMap.hashCode());
 		return result;
 	}
 
 	@Override
-	public boolean equals(Object obj) {
-		if (this == obj)
-			return true;
-		if (obj == null)
-			return false;
-		if (!(obj instanceof FunctionalMap))
-			return false;
+	public boolean equals(final Object obj) {
+		if (this == obj) return true;
+		if (obj == null) return false;
+		if (!(obj instanceof FunctionalMap)) return false;
 
-		FunctionalMap<?, ?> other = (FunctionalMap<?, ?>) obj;
+		final FunctionalMap<?, ?> other = (FunctionalMap<?, ?>) obj;
 
 		if (wrappedMap == null) {
-			if (other.wrappedMap != null)
-				return false;
-		} else if (!wrappedMap.equals(other.wrappedMap))
-			return false;
+			if (other.wrappedMap != null) return false;
+		} else if (!wrappedMap.equals(other.wrappedMap)) return false;
 		return true;
 	}
 }
diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcdata/FunctionalStringTokenizer.java b/BJC-Utils2/src/main/java/bjc/utils/funcdata/FunctionalStringTokenizer.java
index 4723bcd..e068b46 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/funcdata/FunctionalStringTokenizer.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/funcdata/FunctionalStringTokenizer.java
@@ -18,9 +18,8 @@ public class FunctionalStringTokenizer {
 	 *                The string to create a tokenizer from.
 	 * @return A new tokenizer that splits the provided string on spaces.
 	 */
-	public static FunctionalStringTokenizer fromString(String strang) {
-		if (strang == null)
-			throw new NullPointerException("String to tokenize must be non-null");
+	public static FunctionalStringTokenizer fromString(final String strang) {
+		if (strang == null) throw new NullPointerException("String to tokenize must be non-null");
 
 		return new FunctionalStringTokenizer(new StringTokenizer(strang, " "));
 	}
@@ -28,7 +27,7 @@ public class FunctionalStringTokenizer {
 	/*
 	 * The string tokenizer being driven
 	 */
-	private StringTokenizer input;
+	private final StringTokenizer input;
 
 	/**
 	 * Create a functional string tokenizer from a given string
@@ -36,9 +35,8 @@ public class FunctionalStringTokenizer {
 	 * @param inp
 	 *                The string to tokenize
 	 */
-	public FunctionalStringTokenizer(String inp) {
-		if (inp == null)
-			throw new NullPointerException("String to tokenize must be non-null");
+	public FunctionalStringTokenizer(final String inp) {
+		if (inp == null) throw new NullPointerException("String to tokenize must be non-null");
 
 		this.input = new StringTokenizer(inp);
 	}
@@ -52,11 +50,10 @@ public class FunctionalStringTokenizer {
 	 * @param seperators
 	 *                The set of separating tokens to use for splitting
 	 */
-	public FunctionalStringTokenizer(String input, String seperators) {
+	public FunctionalStringTokenizer(final String input, final String seperators) {
 		if (input == null)
 			throw new NullPointerException("String to tokenize must not be null");
-		else if (seperators == null)
-			throw new NullPointerException("Tokens to split on must not be null");
+		else if (seperators == null) throw new NullPointerException("Tokens to split on must not be null");
 
 		this.input = new StringTokenizer(input, seperators);
 	}
@@ -67,9 +64,8 @@ public class FunctionalStringTokenizer {
 	 * @param toWrap
 	 *                The non-functional string tokenizer to wrap
 	 */
-	public FunctionalStringTokenizer(StringTokenizer toWrap) {
-		if (toWrap == null)
-			throw new NullPointerException("Wrapped tokenizer must not be null");
+	public FunctionalStringTokenizer(final StringTokenizer toWrap) {
+		if (toWrap == null) throw new NullPointerException("Wrapped tokenizer must not be null");
 
 		this.input = toWrap;
 	}
@@ -80,9 +76,8 @@ public class FunctionalStringTokenizer {
 	 * @param action
 	 *                The action to execute for each token
 	 */
-	public void forEachToken(Consumer<String> action) {
-		if (action == null)
-			throw new NullPointerException("Action must not be null");
+	public void forEachToken(final Consumer<String> action) {
+		if (action == null) throw new NullPointerException("Action must not be null");
 
 		while (input.hasMoreTokens()) {
 			action.accept(input.nextToken());
@@ -128,7 +123,7 @@ public class FunctionalStringTokenizer {
 	 * @return This tokenizer, converted into a list of strings
 	 */
 	public IList<String> toList() {
-		return toList((String element) -> element);
+		return toList((final String element) -> element);
 	}
 
 	/**
@@ -142,15 +137,14 @@ public class FunctionalStringTokenizer {
 	 *                The function to use to convert tokens.
 	 * @return A list containing all of the converted tokens.
 	 */
-	public <E> IList<E> toList(Function<String, E> transformer) {
-		if (transformer == null)
-			throw new NullPointerException("Transformer must not be null");
+	public <E> IList<E> toList(final Function<String, E> transformer) {
+		if (transformer == null) throw new NullPointerException("Transformer must not be null");
 
-		IList<E> returned = new FunctionalList<>();
+		final IList<E> returned = new FunctionalList<>();
 
 		// Add each token to the list after transforming it
 		forEachToken(token -> {
-			E transformedToken = transformer.apply(token);
+			final E transformedToken = transformer.apply(token);
 
 			returned.add(transformedToken);
 		});
diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcdata/IList.java b/BJC-Utils2/src/main/java/bjc/utils/funcdata/IList.java
index d92d564..de48d6f 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/funcdata/IList.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/funcdata/IList.java
@@ -1,7 +1,5 @@
 package bjc.utils.funcdata;
 
-import bjc.utils.data.IPair;
-
 import java.util.Comparator;
 import java.util.Iterator;
 import java.util.function.BiConsumer;
@@ -11,6 +9,8 @@ import java.util.function.Function;
 import java.util.function.Predicate;
 import java.util.stream.Collector;
 
+import bjc.utils.data.IPair;
+
 /**
  * A wrapper over another list that provides functional operations over it.
  *
@@ -37,7 +37,7 @@ public interface IList<ContainedType> extends Iterable<ContainedType> {
 	 * @return True if every item was successfully added to the list, false
 	 *         otherwise
 	 */
-	default boolean addAll(IList<ContainedType> items) {
+	default boolean addAll(final IList<ContainedType> items) {
 		return items.map(this::add).anyMatch(bl -> bl == false);
 	}
 
@@ -46,16 +46,16 @@ public interface IList<ContainedType> extends Iterable<ContainedType> {
 	 *
 	 * @param items
 	 *                The array of items to add.
-	 * 
+	 *
 	 * @return True if every item was successfully added to the list, false
 	 *         otherwise.
 	 */
 	@SuppressWarnings("unchecked")
-	default boolean addAll(ContainedType... items) {
+	default boolean addAll(final ContainedType... items) {
 		boolean succ = true;
 
-		for(ContainedType item : items) {
-			boolean addSucc = add(item);
+		for (final ContainedType item : items) {
+			final boolean addSucc = add(item);
 
 			succ = succ ? addSucc : false;
 		}
@@ -96,10 +96,10 @@ public interface IList<ContainedType> extends Iterable<ContainedType> {
 	 * @return The reduced list
 	 */
 	default <StateType, ReducedType> ReducedType collect(
-			Collector<ContainedType, StateType, ReducedType> collector) {
-		BiConsumer<StateType, ContainedType> accumulator = collector.accumulator();
+			final Collector<ContainedType, StateType, ReducedType> collector) {
+		final BiConsumer<StateType, ContainedType> accumulator = collector.accumulator();
 
-		StateType initial = collector.supplier().get();
+		final StateType initial = collector.supplier().get();
 		return reduceAux(initial, (value, state) -> {
 			accumulator.accept(state, value);
 
@@ -266,8 +266,8 @@ public interface IList<ContainedType> extends Iterable<ContainedType> {
 	 *                The items to prepend to the list.
 	 */
 	@SuppressWarnings("unchecked")
-	default void prependAll(ContainedType... items) {
-		for(ContainedType item : items) {
+	default void prependAll(final ContainedType... items) {
+		for (final ContainedType item : items) {
 			prepend(item);
 		}
 	}
diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcdata/IMap.java b/BJC-Utils2/src/main/java/bjc/utils/funcdata/IMap.java
index e58409e..0ee7375 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/funcdata/IMap.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/funcdata/IMap.java
@@ -11,7 +11,7 @@ import java.util.function.Function;
  *
  * @param <KeyType>
  *                The type of this map's keys.
- * 
+ *
  * @param <ValueType>
  *                The type of this map's values.
  */
@@ -30,7 +30,7 @@ public interface IMap<KeyType, ValueType> {
 	 * @param action
 	 *                The action to perform on each key in the map.
 	 */
-	default void forEachKey(Consumer<KeyType> action) {
+	default void forEachKey(final Consumer<KeyType> action) {
 		forEach((key, val) -> action.accept(key));
 	}
 
@@ -40,7 +40,7 @@ public interface IMap<KeyType, ValueType> {
 	 * @param action
 	 *                The action to perform on each value in the map.
 	 */
-	default void forEachValue(Consumer<ValueType> action) {
+	default void forEachValue(final Consumer<ValueType> action) {
 		forEach((key, val) -> action.accept(val));
 	}
 
@@ -49,7 +49,7 @@ public interface IMap<KeyType, ValueType> {
 	 *
 	 * @param key
 	 *                The key to check.
-	 * 
+	 *
 	 * @return Whether or not the map contains the key.
 	 */
 	boolean containsKey(KeyType key);
@@ -59,7 +59,7 @@ public interface IMap<KeyType, ValueType> {
 	 *
 	 * @param key
 	 *                The key to look for a value under.
-	 * 
+	 *
 	 * @return The value of the key.
 	 */
 	ValueType get(KeyType key);
@@ -70,17 +70,17 @@ public interface IMap<KeyType, ValueType> {
 	 *
 	 * @param key
 	 *                The key to attempt to retrieve.
-	 * 
+	 *
 	 * @param defaultValue
 	 *                The value to return if the key doesn't exist.
-	 * 
+	 *
 	 * @return The value associated with the key, or the default value if
 	 *         the key doesn't exist.
 	 */
-	default ValueType getOrDefault(KeyType key, ValueType defaultValue) {
+	default ValueType getOrDefault(final KeyType key, final ValueType defaultValue) {
 		try {
 			return get(key);
-		} catch (IllegalArgumentException iaex) {
+		} catch (final IllegalArgumentException iaex) {
 			/*
 			 * We don't care about this, because it indicates a key
 			 * is missing.
@@ -94,10 +94,10 @@ public interface IMap<KeyType, ValueType> {
 	 *
 	 * @param key
 	 *                The key to put the value under.
-	 * 
+	 *
 	 * @param val
 	 *                The value to add.
-	 * 
+	 *
 	 * @return The previous value of the key in the map, or null if the key
 	 *         wasn't in the map. However, note that it may also return null
 	 *         if the key was set to null.
@@ -133,13 +133,13 @@ public interface IMap<KeyType, ValueType> {
 	 *
 	 * @param <V2>
 	 *                The new type of returned values.
-	 * 
+	 *
 	 * @param transformer
 	 *                The function to use to transform values.
-	 * 
+	 *
 	 * @return The map where each value will be transformed after lookup.
 	 */
-	default <V2> IMap<KeyType, V2> transform(Function<ValueType, V2> transformer) {
+	default <V2> IMap<KeyType, V2> transform(final Function<ValueType, V2> transformer) {
 		return new TransformedValueMap<>(this, transformer);
 	}
 
@@ -156,7 +156,7 @@ public interface IMap<KeyType, ValueType> {
 	 *
 	 * @param key
 	 *                The key to remove from the map.
-	 * 
+	 *
 	 * @return The previous value for the key in the map, or null if the key
 	 *         wasn't in the class. NOTE: Just because you received null,
 	 *         doesn't mean the map wasn't changed. It may mean that someone
@@ -177,9 +177,9 @@ public interface IMap<KeyType, ValueType> {
 	 * @return A list of values in this map.
 	 */
 	default IList<ValueType> valueList() {
-		IList<ValueType> returns = new FunctionalList<>();
+		final IList<ValueType> returns = new FunctionalList<>();
 
-		for (KeyType key : keyList()) {
+		for (final KeyType key : keyList()) {
 			returns.add(get(key));
 		}
 
diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcdata/SentryList.java b/BJC-Utils2/src/main/java/bjc/utils/funcdata/SentryList.java
index f52a286..c322743 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/funcdata/SentryList.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/funcdata/SentryList.java
@@ -4,10 +4,11 @@ import java.util.List;
 
 /**
  * A list that logs when items are inserted into it.
- * 
+ *
  * @author bjculkin
  *
- * @param <T> The type of item in the list.
+ * @param <T>
+ *                The type of item in the list.
  */
 public class SentryList<T> extends FunctionalList<T> {
 	/**
@@ -19,19 +20,19 @@ public class SentryList<T> extends FunctionalList<T> {
 
 	/**
 	 * Create a new sentry list backed by an existing list.
-	 * 
+	 *
 	 * @param backing
 	 *                The backing list.
 	 */
-	public SentryList(List<T> backing) {
+	public SentryList(final List<T> backing) {
 		super(backing);
 	}
 
 	@Override
-	public boolean add(T item) {
-		boolean val = super.add(item);
+	public boolean add(final T item) {
+		final boolean val = super.add(item);
 
-		if(val) {
+		if (val) {
 			System.out.println("Added item (" + item + ") to list");
 		}
 
diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcdata/TransformedValueMap.java b/BJC-Utils2/src/main/java/bjc/utils/funcdata/TransformedValueMap.java
index 43bd4d0..0ca1fdc 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/funcdata/TransformedValueMap.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/funcdata/TransformedValueMap.java
@@ -17,10 +17,11 @@ import java.util.function.Function;
  *                The type of the transformed values
  */
 final class TransformedValueMap<OldKey, OldValue, NewValue> implements IMap<OldKey, NewValue> {
-	private IMap<OldKey, OldValue>		backing;
-	private Function<OldValue, NewValue>	transformer;
+	private final IMap<OldKey, OldValue>		backing;
+	private final Function<OldValue, NewValue>	transformer;
 
-	public TransformedValueMap(IMap<OldKey, OldValue> backingMap, Function<OldValue, NewValue> transform) {
+	public TransformedValueMap(final IMap<OldKey, OldValue> backingMap,
+			final Function<OldValue, NewValue> transform) {
 		backing = backingMap;
 		transformer = transform;
 	}
@@ -31,7 +32,7 @@ final class TransformedValueMap<OldKey, OldValue, NewValue> implements IMap<OldK
 	}
 
 	@Override
-	public boolean containsKey(OldKey key) {
+	public boolean containsKey(final OldKey key) {
 		return backing.containsKey(key);
 	}
 
@@ -41,26 +42,26 @@ final class TransformedValueMap<OldKey, OldValue, NewValue> implements IMap<OldK
 	}
 
 	@Override
-	public void forEach(BiConsumer<OldKey, NewValue> action) {
+	public void forEach(final BiConsumer<OldKey, NewValue> action) {
 		backing.forEach((key, value) -> {
 			action.accept(key, transformer.apply(value));
 		});
 	}
 
 	@Override
-	public void forEachKey(Consumer<OldKey> action) {
+	public void forEachKey(final Consumer<OldKey> action) {
 		backing.forEachKey(action);
 	}
 
 	@Override
-	public void forEachValue(Consumer<NewValue> action) {
+	public void forEachValue(final Consumer<NewValue> action) {
 		backing.forEachValue(value -> {
 			action.accept(transformer.apply(value));
 		});
 	}
 
 	@Override
-	public NewValue get(OldKey key) {
+	public NewValue get(final OldKey key) {
 		return transformer.apply(backing.get(key));
 	}
 
@@ -75,17 +76,17 @@ final class TransformedValueMap<OldKey, OldValue, NewValue> implements IMap<OldK
 	}
 
 	@Override
-	public <MappedValue> IMap<OldKey, MappedValue> transform(Function<NewValue, MappedValue> transform) {
+	public <MappedValue> IMap<OldKey, MappedValue> transform(final Function<NewValue, MappedValue> transform) {
 		return new TransformedValueMap<>(this, transform);
 	}
 
 	@Override
-	public NewValue put(OldKey key, NewValue value) {
+	public NewValue put(final OldKey key, final NewValue value) {
 		throw new UnsupportedOperationException("Can't add items to transformed map");
 	}
 
 	@Override
-	public NewValue remove(OldKey key) {
+	public NewValue remove(final OldKey key) {
 		return transformer.apply(backing.remove(key));
 	}
 
diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcdata/bst/BinarySearchTree.java b/BJC-Utils2/src/main/java/bjc/utils/funcdata/bst/BinarySearchTree.java
index e85ae34..8acd477 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/funcdata/bst/BinarySearchTree.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/funcdata/bst/BinarySearchTree.java
@@ -1,13 +1,13 @@
 package bjc.utils.funcdata.bst;
 
-import bjc.utils.funcdata.FunctionalList;
-import bjc.utils.funcdata.IList;
-
 import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.List;
 import java.util.function.Predicate;
 
+import bjc.utils.funcdata.FunctionalList;
+import bjc.utils.funcdata.IList;
+
 /**
  * A binary search tree, with some mild support for functional traversal.
  *
@@ -20,7 +20,7 @@ public class BinarySearchTree<T> {
 	/*
 	 * The comparator for use in ordering items
 	 */
-	private Comparator<T> comparator;
+	private final Comparator<T> comparator;
 
 	/*
 	 * The current count of elements in the tree
@@ -38,9 +38,8 @@ public class BinarySearchTree<T> {
 	 * @param cmp
 	 *                The thing to use for comparing elements
 	 */
-	public BinarySearchTree(Comparator<T> cmp) {
-		if (cmp == null)
-			throw new NullPointerException("Comparator must not be null");
+	public BinarySearchTree(final Comparator<T> cmp) {
+		if (cmp == null) throw new NullPointerException("Comparator must not be null");
 
 		elementCount = 0;
 		comparator = cmp;
@@ -52,7 +51,7 @@ public class BinarySearchTree<T> {
 	 * @param element
 	 *                The data to add to the binary search tree.
 	 */
-	public void addNode(T element) {
+	public void addNode(final T element) {
 		elementCount++;
 
 		if (root == null) {
@@ -73,7 +72,7 @@ public class BinarySearchTree<T> {
 	 *                The distance from the pivot
 	 * @return Whether the adjusted pivot is with the list
 	 */
-	private boolean adjustedPivotInBounds(IList<T> elements, int pivot, int pivotAdjustment) {
+	private boolean adjustedPivotInBounds(final IList<T> elements, final int pivot, final int pivotAdjustment) {
 		return pivot - pivotAdjustment >= 0 && pivot + pivotAdjustment < elements.getSize();
 	}
 
@@ -83,7 +82,7 @@ public class BinarySearchTree<T> {
 	 * Takes O(N) time, but also O(N) space.
 	 */
 	public void balance() {
-		IList<T> elements = new FunctionalList<>();
+		final IList<T> elements = new FunctionalList<>();
 
 		// Add each element to the list in sorted order
 		root.forEach(TreeLinearizationMethod.INORDER, element -> elements.add(element));
@@ -92,7 +91,7 @@ public class BinarySearchTree<T> {
 		root = null;
 
 		// Set up the pivot and adjustment for readding elements
-		int pivot = elements.getSize() / 2;
+		final int pivot = elements.getSize() / 2;
 		int pivotAdjustment = 0;
 
 		// Add elements until there aren't any left
@@ -129,7 +128,7 @@ public class BinarySearchTree<T> {
 	 * @param element
 	 *                The node to delete
 	 */
-	public void deleteNode(T element) {
+	public void deleteNode(final T element) {
 		elementCount--;
 
 		root.delete(element, comparator);
@@ -151,7 +150,7 @@ public class BinarySearchTree<T> {
 	 *                The node to check the presence of for the tree.
 	 * @return Whether or not the node is in the tree.
 	 */
-	public boolean isInTree(T element) {
+	public boolean isInTree(final T element) {
 		return root.contains(element, comparator);
 	}
 
@@ -163,11 +162,10 @@ public class BinarySearchTree<T> {
 	 * @param traversalPredicate
 	 *                The function to use until it fails
 	 */
-	public void traverse(TreeLinearizationMethod linearizationMethod, Predicate<T> traversalPredicate) {
+	public void traverse(final TreeLinearizationMethod linearizationMethod, final Predicate<T> traversalPredicate) {
 		if (linearizationMethod == null)
 			throw new NullPointerException("Linearization method must not be null");
-		else if (traversalPredicate == null)
-			throw new NullPointerException("Predicate must not be nulls");
+		else if (traversalPredicate == null) throw new NullPointerException("Predicate must not be nulls");
 
 		root.forEach(linearizationMethod, traversalPredicate);
 	}
@@ -176,7 +174,7 @@ public class BinarySearchTree<T> {
 	 * Remove all soft-deleted nodes from the tree.
 	 */
 	public void trim() {
-		List<T> nodes = new ArrayList<>(elementCount);
+		final List<T> nodes = new ArrayList<>(elementCount);
 
 		// Add all non-soft deleted nodes to the tree in insertion order
 		traverse(TreeLinearizationMethod.PREORDER, node -> {
@@ -201,28 +199,22 @@ public class BinarySearchTree<T> {
 		final int prime = 31;
 		int result = 1;
 		result = prime * result + elementCount;
-		result = prime * result + ((root == null) ? 0 : root.hashCode());
+		result = prime * result + (root == null ? 0 : root.hashCode());
 		return result;
 	}
 
 	@Override
-	public boolean equals(Object obj) {
-		if (this == obj)
-			return true;
-		if (obj == null)
-			return false;
-		if (!(obj instanceof BinarySearchTree<?>))
-			return false;
+	public boolean equals(final Object obj) {
+		if (this == obj) return true;
+		if (obj == null) return false;
+		if (!(obj instanceof BinarySearchTree<?>)) return false;
 
-		BinarySearchTree<?> other = (BinarySearchTree<?>) obj;
+		final BinarySearchTree<?> other = (BinarySearchTree<?>) obj;
 
-		if (elementCount != other.elementCount)
-			return false;
+		if (elementCount != other.elementCount) return false;
 		if (root == null) {
-			if (other.root != null)
-				return false;
-		} else if (!root.equals(other.root))
-			return false;
+			if (other.root != null) return false;
+		} else if (!root.equals(other.root)) return false;
 
 		return true;
 	}
diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcdata/bst/BinarySearchTreeLeaf.java b/BJC-Utils2/src/main/java/bjc/utils/funcdata/bst/BinarySearchTreeLeaf.java
index fe30dad..8c4f3f0 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/funcdata/bst/BinarySearchTreeLeaf.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/funcdata/bst/BinarySearchTreeLeaf.java
@@ -30,25 +30,24 @@ public class BinarySearchTreeLeaf<T> implements ITreePart<T> {
 	 * @param element
 	 *                The data for the leaf to hold.
 	 */
-	public BinarySearchTreeLeaf(T element) {
+	public BinarySearchTreeLeaf(final T element) {
 		data = element;
 	}
 
 	@Override
-	public void add(T element, Comparator<T> comparator) {
+	public void add(final T element, final Comparator<T> comparator) {
 		throw new IllegalArgumentException("Can't add to a leaf.");
 	}
 
 	@Override
-	public <E> E collapse(Function<T, E> leafTransformer, BiFunction<E, E, E> branchCollapser) {
-		if (leafTransformer == null)
-			throw new NullPointerException("Transformer must not be null");
+	public <E> E collapse(final Function<T, E> leafTransformer, final BiFunction<E, E, E> branchCollapser) {
+		if (leafTransformer == null) throw new NullPointerException("Transformer must not be null");
 
 		return leafTransformer.apply(data);
 	}
 
 	@Override
-	public boolean contains(T element, Comparator<T> comparator) {
+	public boolean contains(final T element, final Comparator<T> comparator) {
 		return this.data.equals(element);
 	}
 
@@ -58,16 +57,15 @@ public class BinarySearchTreeLeaf<T> implements ITreePart<T> {
 	}
 
 	@Override
-	public void delete(T element, Comparator<T> comparator) {
+	public void delete(final T element, final Comparator<T> comparator) {
 		if (data.equals(element)) {
 			isDeleted = true;
 		}
 	}
 
 	@Override
-	public boolean directedWalk(DirectedWalkFunction<T> treeWalker) {
-		if (treeWalker == null)
-			throw new NullPointerException("Tree walker must not be null");
+	public boolean directedWalk(final DirectedWalkFunction<T> treeWalker) {
+		if (treeWalker == null) throw new NullPointerException("Tree walker must not be null");
 
 		switch (treeWalker.walk(data)) {
 		case SUCCESS:
@@ -82,9 +80,9 @@ public class BinarySearchTreeLeaf<T> implements ITreePart<T> {
 	}
 
 	@Override
-	public boolean forEach(TreeLinearizationMethod linearizationMethod, Predicate<T> traversalPredicate) {
-		if (traversalPredicate == null)
-			throw new NullPointerException("Predicate must not be null");
+	public boolean forEach(final TreeLinearizationMethod linearizationMethod,
+			final Predicate<T> traversalPredicate) {
+		if (traversalPredicate == null) throw new NullPointerException("Predicate must not be null");
 
 		return traversalPredicate.test(data);
 	}
@@ -98,29 +96,23 @@ public class BinarySearchTreeLeaf<T> implements ITreePart<T> {
 	public int hashCode() {
 		final int prime = 31;
 		int result = 1;
-		result = prime * result + ((data == null) ? 0 : data.hashCode());
+		result = prime * result + (data == null ? 0 : data.hashCode());
 		result = prime * result + (isDeleted ? 1231 : 1237);
 		return result;
 	}
 
 	@Override
-	public boolean equals(Object obj) {
-		if (this == obj)
-			return true;
-		if (obj == null)
-			return false;
-		if (!(obj instanceof BinarySearchTreeLeaf<?>))
-			return false;
+	public boolean equals(final Object obj) {
+		if (this == obj) return true;
+		if (obj == null) return false;
+		if (!(obj instanceof BinarySearchTreeLeaf<?>)) return false;
 
-		BinarySearchTreeLeaf<?> other = (BinarySearchTreeLeaf<?>) obj;
+		final BinarySearchTreeLeaf<?> other = (BinarySearchTreeLeaf<?>) obj;
 
 		if (data == null) {
-			if (other.data != null)
-				return false;
-		} else if (!data.equals(other.data))
-			return false;
-		if (isDeleted != other.isDeleted)
-			return false;
+			if (other.data != null) return false;
+		} else if (!data.equals(other.data)) return false;
+		if (isDeleted != other.isDeleted) return false;
 
 		return true;
 	}
diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcdata/bst/BinarySearchTreeNode.java b/BJC-Utils2/src/main/java/bjc/utils/funcdata/bst/BinarySearchTreeNode.java
index 527f221..9f45c17 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/funcdata/bst/BinarySearchTreeNode.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/funcdata/bst/BinarySearchTreeNode.java
@@ -1,15 +1,15 @@
 package bjc.utils.funcdata.bst;
 
-import java.util.Comparator;
-import java.util.function.BiFunction;
-import java.util.function.Function;
-import java.util.function.Predicate;
-
 import static bjc.utils.funcdata.bst.DirectedWalkFunction.DirectedWalkResult.FAILURE;
 import static bjc.utils.funcdata.bst.DirectedWalkFunction.DirectedWalkResult.LEFT;
 import static bjc.utils.funcdata.bst.DirectedWalkFunction.DirectedWalkResult.RIGHT;
 import static bjc.utils.funcdata.bst.DirectedWalkFunction.DirectedWalkResult.SUCCESS;
 
+import java.util.Comparator;
+import java.util.function.BiFunction;
+import java.util.function.Function;
+import java.util.function.Predicate;
+
 /**
  * A binary node in a tree.
  *
@@ -39,16 +39,15 @@ public class BinarySearchTreeNode<T> extends BinarySearchTreeLeaf<T> {
 	 * @param rght
 	 *                The right child of this node.
 	 */
-	public BinarySearchTreeNode(T element, ITreePart<T> lft, ITreePart<T> rght) {
+	public BinarySearchTreeNode(final T element, final ITreePart<T> lft, final ITreePart<T> rght) {
 		super(element);
 		this.left = lft;
 		this.right = rght;
 	}
 
 	@Override
-	public void add(T element, Comparator<T> comparator) {
-		if (comparator == null)
-			throw new NullPointerException("Comparator must not be null");
+	public void add(final T element, final Comparator<T> comparator) {
+		if (comparator == null) throw new NullPointerException("Comparator must not be null");
 
 		switch (comparator.compare(data, element)) {
 		case -1:
@@ -61,8 +60,7 @@ public class BinarySearchTreeNode<T> extends BinarySearchTreeLeaf<T> {
 		case 0:
 			if (isDeleted) {
 				isDeleted = false;
-			} else
-				throw new IllegalArgumentException("Can't add duplicate values");
+			} else throw new IllegalArgumentException("Can't add duplicate values");
 			break;
 		case 1:
 			if (right == null) {
@@ -77,19 +75,20 @@ public class BinarySearchTreeNode<T> extends BinarySearchTreeLeaf<T> {
 	}
 
 	@Override
-	public <E> E collapse(Function<T, E> nodeCollapser, BiFunction<E, E, E> branchCollapser) {
+	public <E> E collapse(final Function<T, E> nodeCollapser, final BiFunction<E, E, E> branchCollapser) {
 		if (nodeCollapser == null || branchCollapser == null)
 			throw new NullPointerException("Collapser must not be null");
 
-		E collapsedNode = nodeCollapser.apply(data);
+		final E collapsedNode = nodeCollapser.apply(data);
 
 		if (left != null) {
-			E collapsedLeftBranch = left.collapse(nodeCollapser, branchCollapser);
+			final E collapsedLeftBranch = left.collapse(nodeCollapser, branchCollapser);
 
 			if (right != null) {
-				E collapsedRightBranch = right.collapse(nodeCollapser, branchCollapser);
+				final E collapsedRightBranch = right.collapse(nodeCollapser, branchCollapser);
 
-				E collapsedBranches = branchCollapser.apply(collapsedLeftBranch, collapsedRightBranch);
+				final E collapsedBranches = branchCollapser.apply(collapsedLeftBranch,
+						collapsedRightBranch);
 
 				return branchCollapser.apply(collapsedNode, collapsedBranches);
 			}
@@ -98,7 +97,7 @@ public class BinarySearchTreeNode<T> extends BinarySearchTreeLeaf<T> {
 		}
 
 		if (right != null) {
-			E collapsedRightBranch = right.collapse(nodeCollapser, branchCollapser);
+			final E collapsedRightBranch = right.collapse(nodeCollapser, branchCollapser);
 
 			return branchCollapser.apply(collapsedNode, collapsedRightBranch);
 		}
@@ -107,9 +106,8 @@ public class BinarySearchTreeNode<T> extends BinarySearchTreeLeaf<T> {
 	}
 
 	@Override
-	public boolean contains(T element, Comparator<T> comparator) {
-		if (comparator == null)
-			throw new NullPointerException("Comparator must not be null");
+	public boolean contains(final T element, final Comparator<T> comparator) {
+		if (comparator == null) throw new NullPointerException("Comparator must not be null");
 
 		return directedWalk(currentElement -> {
 			switch (comparator.compare(element, currentElement)) {
@@ -126,9 +124,8 @@ public class BinarySearchTreeNode<T> extends BinarySearchTreeLeaf<T> {
 	}
 
 	@Override
-	public void delete(T element, Comparator<T> comparator) {
-		if (comparator == null)
-			throw new NullPointerException("Comparator must not be null");
+	public void delete(final T element, final Comparator<T> comparator) {
+		if (comparator == null) throw new NullPointerException("Comparator must not be null");
 
 		directedWalk(currentElement -> {
 			switch (comparator.compare(data, element)) {
@@ -146,9 +143,8 @@ public class BinarySearchTreeNode<T> extends BinarySearchTreeLeaf<T> {
 	}
 
 	@Override
-	public boolean directedWalk(DirectedWalkFunction<T> treeWalker) {
-		if (treeWalker == null)
-			throw new NullPointerException("Walker must not be null");
+	public boolean directedWalk(final DirectedWalkFunction<T> treeWalker) {
+		if (treeWalker == null) throw new NullPointerException("Walker must not be null");
 
 		switch (treeWalker.walk(data)) {
 		case SUCCESS:
@@ -165,11 +161,11 @@ public class BinarySearchTreeNode<T> extends BinarySearchTreeLeaf<T> {
 	}
 
 	@Override
-	public boolean forEach(TreeLinearizationMethod linearizationMethod, Predicate<T> traversalPredicate) {
+	public boolean forEach(final TreeLinearizationMethod linearizationMethod,
+			final Predicate<T> traversalPredicate) {
 		if (linearizationMethod == null)
 			throw new NullPointerException("Linearization method must not be null");
-		else if (traversalPredicate == null)
-			throw new NullPointerException("Predicate must not be null");
+		else if (traversalPredicate == null) throw new NullPointerException("Predicate must not be null");
 
 		switch (linearizationMethod) {
 		case PREORDER:
@@ -184,48 +180,41 @@ public class BinarySearchTreeNode<T> extends BinarySearchTreeLeaf<T> {
 		}
 	}
 
-	private boolean inorderTraverse(TreeLinearizationMethod linearizationMethod, Predicate<T> traversalPredicate) {
-		if (!traverseLeftBranch(linearizationMethod, traversalPredicate))
-			return false;
+	private boolean inorderTraverse(final TreeLinearizationMethod linearizationMethod,
+			final Predicate<T> traversalPredicate) {
+		if (!traverseLeftBranch(linearizationMethod, traversalPredicate)) return false;
 
-		if (!traverseElement(traversalPredicate))
-			return false;
+		if (!traverseElement(traversalPredicate)) return false;
 
-		if (!traverseRightBranch(linearizationMethod, traversalPredicate))
-			return false;
+		if (!traverseRightBranch(linearizationMethod, traversalPredicate)) return false;
 
 		return true;
 	}
 
-	private boolean postorderTraverse(TreeLinearizationMethod linearizationMethod,
-			Predicate<T> traversalPredicate) {
-		if (!traverseLeftBranch(linearizationMethod, traversalPredicate))
-			return false;
+	private boolean postorderTraverse(final TreeLinearizationMethod linearizationMethod,
+			final Predicate<T> traversalPredicate) {
+		if (!traverseLeftBranch(linearizationMethod, traversalPredicate)) return false;
 
-		if (!traverseRightBranch(linearizationMethod, traversalPredicate))
-			return false;
+		if (!traverseRightBranch(linearizationMethod, traversalPredicate)) return false;
 
-		if (!traverseElement(traversalPredicate))
-			return false;
+		if (!traverseElement(traversalPredicate)) return false;
 
 		return true;
 
 	}
 
-	private boolean preorderTraverse(TreeLinearizationMethod linearizationMethod, Predicate<T> traversalPredicate) {
-		if (!traverseElement(traversalPredicate))
-			return false;
+	private boolean preorderTraverse(final TreeLinearizationMethod linearizationMethod,
+			final Predicate<T> traversalPredicate) {
+		if (!traverseElement(traversalPredicate)) return false;
 
-		if (!traverseLeftBranch(linearizationMethod, traversalPredicate))
-			return false;
+		if (!traverseLeftBranch(linearizationMethod, traversalPredicate)) return false;
 
-		if (!traverseRightBranch(linearizationMethod, traversalPredicate))
-			return false;
+		if (!traverseRightBranch(linearizationMethod, traversalPredicate)) return false;
 
 		return true;
 	}
 
-	private boolean traverseElement(Predicate<T> traversalPredicate) {
+	private boolean traverseElement(final Predicate<T> traversalPredicate) {
 		boolean nodeSuccesfullyTraversed;
 
 		if (isDeleted) {
@@ -237,8 +226,8 @@ public class BinarySearchTreeNode<T> extends BinarySearchTreeLeaf<T> {
 		return nodeSuccesfullyTraversed;
 	}
 
-	private boolean traverseLeftBranch(TreeLinearizationMethod linearizationMethod,
-			Predicate<T> traversalPredicate) {
+	private boolean traverseLeftBranch(final TreeLinearizationMethod linearizationMethod,
+			final Predicate<T> traversalPredicate) {
 		boolean leftSuccesfullyTraversed;
 
 		if (left == null) {
@@ -250,8 +239,8 @@ public class BinarySearchTreeNode<T> extends BinarySearchTreeLeaf<T> {
 		return leftSuccesfullyTraversed;
 	}
 
-	private boolean traverseRightBranch(TreeLinearizationMethod linearizationMethod,
-			Predicate<T> traversalPredicate) {
+	private boolean traverseRightBranch(final TreeLinearizationMethod linearizationMethod,
+			final Predicate<T> traversalPredicate) {
 		boolean rightSuccesfullyTraversed;
 
 		if (right == null) {
@@ -272,33 +261,26 @@ public class BinarySearchTreeNode<T> extends BinarySearchTreeLeaf<T> {
 	public int hashCode() {
 		final int prime = 31;
 		int result = super.hashCode();
-		result = prime * result + ((left == null) ? 0 : left.hashCode());
-		result = prime * result + ((right == null) ? 0 : right.hashCode());
+		result = prime * result + (left == null ? 0 : left.hashCode());
+		result = prime * result + (right == null ? 0 : right.hashCode());
 		return result;
 	}
 
 	@Override
-	public boolean equals(Object obj) {
-		if (this == obj)
-			return true;
-		if (!super.equals(obj))
-			return false;
-		if (!(obj instanceof BinarySearchTreeNode<?>))
-			return false;
+	public boolean equals(final Object obj) {
+		if (this == obj) return true;
+		if (!super.equals(obj)) return false;
+		if (!(obj instanceof BinarySearchTreeNode<?>)) return false;
 
-		BinarySearchTreeNode<?> other = (BinarySearchTreeNode<?>) obj;
+		final BinarySearchTreeNode<?> other = (BinarySearchTreeNode<?>) obj;
 
 		if (left == null) {
-			if (other.left != null)
-				return false;
-		} else if (!left.equals(other.left))
-			return false;
+			if (other.left != null) return false;
+		} else if (!left.equals(other.left)) return false;
 
 		if (right == null) {
-			if (other.right != null)
-				return false;
-		} else if (!right.equals(other.right))
-			return false;
+			if (other.right != null) return false;
+		} else if (!right.equals(other.right)) return false;
 
 		return true;
 	}
diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcdata/theory/Bifunctor.java b/BJC-Utils2/src/main/java/bjc/utils/funcdata/theory/Bifunctor.java
index 5380b24..13c1709 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/funcdata/theory/Bifunctor.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/funcdata/theory/Bifunctor.java
@@ -15,9 +15,9 @@ import java.util.function.Function;
 public interface Bifunctor<LeftType, RightType> {
 	/**
 	 * Alias for functor mapping.
-	 * 
+	 *
 	 * @author EVE
-	 * 
+	 *
 	 * @param <OldLeft>
 	 * @param <OldRight>
 	 * @param <NewLeft>
@@ -30,7 +30,7 @@ public interface Bifunctor<LeftType, RightType> {
 
 	/**
 	 * Alias for left functor mapping.
-	 * 
+	 *
 	 * @author EVE
 	 *
 	 * @param <OldLeft>
@@ -44,7 +44,7 @@ public interface Bifunctor<LeftType, RightType> {
 
 	/**
 	 * Alias for right functor mapping.
-	 * 
+	 *
 	 * @author EVE
 	 *
 	 * @param <OldLeft>
@@ -75,12 +75,12 @@ public interface Bifunctor<LeftType, RightType> {
 	 * @return A function that maps over both parts of the pair
 	 */
 	public default <OldLeft, OldRight, NewLeft, NewRight> BifunctorMap<OldLeft, OldRight, NewLeft, NewRight> bimap(
-			Function<OldLeft, NewLeft> leftFunc, Function<OldRight, NewRight> rightFunc) {
-		BifunctorMap<OldLeft, OldRight, NewLeft, NewRight> bimappedFunc = (argPair) -> {
-			LeftBifunctorMap<OldLeft, OldRight, NewLeft> leftMapper = argPair.fmapLeft(leftFunc);
+			final Function<OldLeft, NewLeft> leftFunc, final Function<OldRight, NewRight> rightFunc) {
+		final BifunctorMap<OldLeft, OldRight, NewLeft, NewRight> bimappedFunc = (argPair) -> {
+			final LeftBifunctorMap<OldLeft, OldRight, NewLeft> leftMapper = argPair.fmapLeft(leftFunc);
 
-			Bifunctor<NewLeft, OldRight> leftMappedFunctor = leftMapper.apply(argPair);
-			RightBifunctorMap<NewLeft, OldRight, NewRight> rightMapper = leftMappedFunctor
+			final Bifunctor<NewLeft, OldRight> leftMappedFunctor = leftMapper.apply(argPair);
+			final RightBifunctorMap<NewLeft, OldRight, NewRight> rightMapper = leftMappedFunctor
 					.fmapRight(rightFunc);
 
 			return rightMapper.apply(leftMappedFunctor);