org.organicdesign.fp.collections

Class RangeOfInt

java.lang.Object

org.organicdesign.fp.collections.RangeOfInt

All Implemented Interfaces:

Serializable, Iterable<Integer>, Collection<Integer>, List<Integer>, Sized, UnmodCollection<Integer>, UnmodIterable<Integer>, UnmodList<Integer>, UnmodSortedCollection<Integer>, UnmodSortedIterable<Integer>, Transformable<Integer>

public class RangeOfInt
extends Object
implements UnmodList<Integer>, Serializable

An efficient (in both time and memory) implementation of List. If you want to compare a RangeOfInt to generic List<Integer>, use RangeOfInt.LIST_EQUATOR so that the hashCodes will be compatible. A RangeOfInt is an indexed sequence of integers. It currently assumes a step of 1. Like everything in Java and similar classes in Clojure, Python, and Scala, it is inclusive of the start value but exclusive of the end. In theory, a class like this could be made for anything that can provide it's next() and previous() item and a size. To do that, Integer would need to implement something that defined what the next() and previous() values. Currently limited to Integer.MIN_VALUE to Integer.MAX_VALUE.

See Also:

Serialized Form

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	RangeOfInt.Equat

Nested classes/interfaces inherited from interface org.organicdesign.fp.collections.UnmodList

UnmodList.AbstractUnmodList<E>

Method Summary

Modifier and Type	Method and Description
boolean	contains(int i) Returns true if the number is within the bounds of this range (low end incluive, high end exclusive).
boolean	contains(Object o) Though this overrides List.contains(Object o), it is effectively a convenience method for calling contains(int i).
boolean	equals(Object other)
Integer	get(int idx)
int	hashCode()
int	indexOf(Object o) Unlike most implementations of List, this method has excellent O(1) performance! The default implementation of this method has O(this.size()) performance.
int	lastIndexOf(Object o) Unlike most implementations of List, this method has excellent O(1) performance! The default implementation of this method has O(this.size()) performance.
UnmodListIterator<Integer>	listIterator(int startIdx) Subclasses should override this when they can do so more efficiently.
static RangeOfInt	of(Number e)
static RangeOfInt	of(Number s, Number e)
int	size() Returns the number of items in this collection or iterable.
RangeOfInt	subList(int fromIndex, int toIndex)

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.organicdesign.fp.collections.UnmodList

add, add, addAll, addAll, clear, containsAll, isEmpty, iterator, listIterator, permutations, remove, remove, removeAll, removeIf, replaceAll, retainAll, set, sort, toArray, toArray

Methods inherited from interface java.util.List

spliterator

Methods inherited from interface java.util.Collection

parallelStream, stream

Methods inherited from interface org.organicdesign.fp.collections.UnmodSortedIterable

castFromList, castFromSortedMap, castFromSortedSet, equal

Methods inherited from interface org.organicdesign.fp.collections.UnmodIterable

concat, drop, dropWhile, filter, flatMap, fold, foldUntil, hash, head, map, precat, take, takeWhile, toString

Methods inherited from interface java.lang.Iterable

forEach

Methods inherited from interface org.organicdesign.fp.xform.Transformable

toImList, toImMap, toImRrbt, toImSet, toImSortedMap, toImSortedSet, toMutableList, toMutableMap, toMutableRrbt, toMutableSet, toMutableSortedMap, toMutableSortedSet

Method Detail

of

public static RangeOfInt of(Number s,
                            Number e)

of

public static RangeOfInt of(Number e)

contains

public boolean contains(int i)

Returns true if the number is within the bounds of this range (low end incluive, high end exclusive). In math terms, returns true if the argument is [low, high). False otherwise. This is an efficient method when the compiler can see that it's being passed a primitive int, but contains(Object o) delegates to this method when it's passed a reasonable and unambiguous argument.

contains

public boolean contains(Object o)

Though this overrides List.contains(Object o), it is effectively a convenience method for calling contains(int i). Therefore, it only accepts Integers, Longs, BigIntegers, and Strings that parse as signed decimal Integers. It does not accept Numbers since they can't easily be checked for truncation and floating-point might not round properly with respect to bounds, or might not make sense if you are using your range to define a set of integers. Handles truncation (returns false) for the types it accepts. Throws exceptions for types it does not accept. Thanks for all the help from codereview.stackexchange: http://codereview.stackexchange.com/questions/100846/rounding-and-truncation-in-intrange-containsobject-o

Specified by:

contains in interface Collection<Integer>

Specified by:

contains in interface List<Integer>

Specified by:

contains in interface UnmodList<Integer>

Parameters:

o - an Integer, Long, BigInteger, or String that parses as a signed decimal Integer.

Returns:

true if the number is within the bounds of this range (high end is exclusive). False otherwise.

Throws:

IllegalArgumentException - if the argument is not an Integer, Long, BigInteger, or String.

NumberFormatException - if a String argument cannot be parsed using Integer.valueOf().

get

public Integer get(int idx)

Specified by:

get in interface List<Integer>

indexOf

public int indexOf(Object o)

Unlike most implementations of List, this method has excellent O(1) performance! The default implementation of this method has O(this.size()) performance. If you call this much, you probably want to use a Map<Integer,T> instead for O(1) performance.

Specified by:

indexOf in interface List<Integer>

Specified by:

indexOf in interface UnmodList<Integer>

lastIndexOf

public int lastIndexOf(Object o)

Unlike most implementations of List, this method has excellent O(1) performance! The default implementation of this method has O(this.size()) performance.

Specified by:

lastIndexOf in interface List<Integer>

Specified by:

lastIndexOf in interface UnmodList<Integer>

size

public int size()

Description copied from interface: Sized

Returns the number of items in this collection or iterable.

Specified by:

size in interface Collection<Integer>

Specified by:

size in interface List<Integer>

Specified by:

size in interface Sized

hashCode

public int hashCode()

Specified by:

hashCode in interface Collection<Integer>

Specified by:

hashCode in interface List<Integer>

Overrides:

hashCode in class Object

equals

public boolean equals(Object other)

Specified by:

equals in interface Collection<Integer>

Specified by:

equals in interface List<Integer>

Overrides:

equals in class Object

listIterator

public UnmodListIterator<Integer> listIterator(int startIdx)

Subclasses should override this when they can do so more efficiently. Iterates from start of range (inclusive) up-to, but excluding, the end of the range. I'm not sure this is a good idea, but Python, Clojure, Scala, and just about everything in Java expects similar behavior.

Specified by:

listIterator in interface List<Integer>

Specified by:

listIterator in interface UnmodList<Integer>

subList

public RangeOfInt subList(int fromIndex,
                          int toIndex)

Specified by:

subList in interface List<Integer>

Specified by:

subList in interface UnmodList<Integer>