Range (Cobble Lang 4.6.0 API)

java.lang.Object
- net.hasor.cobble.ref.Range<T>

所有已实现的接口:

Serializable

直接已知子类:

RandomRatio.Boundary
```
public class Range<T>
extends Object
implements Serializable
```
An immutable range of objects from a minimum to maximum point inclusive.

The objects need to either be implementations of Comparable or you need to supply a Comparator.

#ThreadSafe# if the objects and comparator are thread-safe

从以下版本开始:

3.0

另请参阅:

序列化表格

构造器概要

构造器
限定符构造器和说明

protected Range(T element1, T element2, Comparator<T> comp)
Creates an instance.

构造器
限定符	构造器和说明
`protected`	`Range(T element1, T element2, Comparator<T> comp)` Creates an instance.

方法概要

所有方法静态方法实例方法具体方法
限定符和类型	方法和说明
`static <T extends Comparable<T>> Range<T>`	`between(T fromInclusive, T toInclusive)` Obtains a range with the specified minimum and maximum values (both inclusive).
`static <T> Range<T>`	`between(T fromInclusive, T toInclusive, Comparator<T> comparator)` Obtains a range with the specified minimum and maximum values (both inclusive).
`boolean`	`contains(T element)` Checks whether the specified element occurs within this range.
`boolean`	`containsRange(Range<T> otherRange)` Checks whether this range contains all the elements of the specified range.
`int`	`elementCompareTo(T element)` Checks where the specified element occurs relative to this range.
`boolean`	`equals(Object obj)` Compares this range to another object to test if they are equal.
`Comparator<T>`	`getComparator()` Gets the comparator being used to determine if objects are within the range.
`T`	`getMaximum()` Gets the maximum value in this range.
`T`	`getMinimum()` Gets the minimum value in this range.
`int`	`hashCode()` Gets a suitable hash code for the range.
`Range<T>`	`intersectionWith(Range<T> other)` Calculate the intersection of `this` and an overlapping Range.
`static <T extends Comparable<T>> Range<T>`	`is(T element)` Obtains a range using the specified element as both the minimum and maximum in this range.
`static <T> Range<T>`	`is(T element, Comparator<T> comparator)` Obtains a range using the specified element as both the minimum and maximum in this range.
`boolean`	`isAfter(T element)` Checks whether this range is after the specified element.
`boolean`	`isAfterRange(Range<T> otherRange)` Checks whether this range is completely after the specified range.
`boolean`	`isBefore(T element)` Checks whether this range is before the specified element.
`boolean`	`isBeforeRange(Range<T> otherRange)` Checks whether this range is completely before the specified range.
`boolean`	`isEndedBy(T element)` Checks whether this range ends with the specified element.
`boolean`	`isNaturalOrdering()` Whether or not the Range is using the natural ordering of the elements.
`boolean`	`isOverlappedBy(Range<T> otherRange)` Checks whether this range is overlapped by the specified range.
`boolean`	`isStartedBy(T element)` Checks whether this range starts with the specified element.
`String`	`toString()` Gets the range as a `String`.
`String`	`toString(String format)` Formats the receiver using the given format.

从类继承的方法 java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- 构造器详细资料
  - Range
```
protected Range(T element1,
                T element2,
                Comparator<T> comp)
```
    Creates an instance.
    
    参数:
    
    element1 - the first element, not null
    
    element2 - the second element, not null
    
    comp - the comparator to be used, null for natural ordering
- 方法详细资料
  - is
```
public static <T extends Comparable<T>> Range<T> is(T element)
```
    Obtains a range using the specified element as both the minimum and maximum in this range.
    
    The range uses the natural ordering of the elements to determine where values lie in the range.
    
    类型参数:
    
    T - the type of the elements in this range
    
    参数:
    
    element - the value to use for this range, not null
    
    返回:
    
    the range object, not null
    
    抛出:
    
    IllegalArgumentException - if the element is null
    
    ClassCastException - if the element is not Comparable
  - is
```
public static <T> Range<T> is(T element,
                              Comparator<T> comparator)
```
    Obtains a range using the specified element as both the minimum and maximum in this range.
    
    The range uses the specified Comparator to determine where values lie in the range.
    
    类型参数:
    
    T - the type of the elements in this range
    
    参数:
    
    element - the value to use for this range, must not be null
    
    comparator - the comparator to be used, null for natural ordering
    
    返回:
    
    the range object, not null
    
    抛出:
    
    IllegalArgumentException - if the element is null
    
    ClassCastException - if using natural ordering and the elements are not Comparable
  - between
```
public static <T extends Comparable<T>> Range<T> between(T fromInclusive,
                                                         T toInclusive)
```
    Obtains a range with the specified minimum and maximum values (both inclusive).
    
    The range uses the natural ordering of the elements to determine where values lie in the range.
    
    The arguments may be passed in the order (min,max) or (max,min). The getMinimum and getMaximum methods will return the correct values.
    
    类型参数:
    
    T - the type of the elements in this range
    
    参数:
    
    fromInclusive - the first value that defines the edge of the range, inclusive
    
    toInclusive - the second value that defines the edge of the range, inclusive
    
    返回:
    
    the range object, not null
    
    抛出:
    
    IllegalArgumentException - if either element is null
    
    ClassCastException - if the elements are not Comparable
  - between
```
public static <T> Range<T> between(T fromInclusive,
                                   T toInclusive,
                                   Comparator<T> comparator)
```
    Obtains a range with the specified minimum and maximum values (both inclusive).
    
    The range uses the specified Comparator to determine where values lie in the range.
    
    The arguments may be passed in the order (min,max) or (max,min). The getMinimum and getMaximum methods will return the correct values.
    
    类型参数:
    
    T - the type of the elements in this range
    
    参数:
    
    fromInclusive - the first value that defines the edge of the range, inclusive
    
    toInclusive - the second value that defines the edge of the range, inclusive
    
    comparator - the comparator to be used, null for natural ordering
    
    返回:
    
    the range object, not null
    
    抛出:
    
    IllegalArgumentException - if either element is null
    
    ClassCastException - if using natural ordering and the elements are not Comparable
  - getMinimum
```
public T getMinimum()
```
    Gets the minimum value in this range.
    
    返回:
    
    the minimum value in this range, not null
  - getMaximum
```
public T getMaximum()
```
    Gets the maximum value in this range.
    
    返回:
    
    the maximum value in this range, not null
  - getComparator
```
public Comparator<T> getComparator()
```
    Gets the comparator being used to determine if objects are within the range.
    
    Natural ordering uses an internal comparator implementation, thus this method never returns null. See isNaturalOrdering().
    
    返回:
    
    the comparator being used, not null
  - isNaturalOrdering
```
public boolean isNaturalOrdering()
```
    Whether or not the Range is using the natural ordering of the elements.
    
    Natural ordering uses an internal comparator implementation, thus this method is the only way to check if a null comparator was specified.
    
    返回:
    
    true if using natural ordering
  - contains
```
public boolean contains(T element)
```
    Checks whether the specified element occurs within this range.
    
    参数:
    
    element - the element to check for, null returns false
    
    返回:
    
    true if the specified element occurs within this range
  - isAfter
```
public boolean isAfter(T element)
```
    Checks whether this range is after the specified element.
    
    参数:
    
    element - the element to check for, null returns false
    
    返回:
    
    true if this range is entirely after the specified element
  - isStartedBy
```
public boolean isStartedBy(T element)
```
    Checks whether this range starts with the specified element.
    
    参数:
    
    element - the element to check for, null returns false
    
    返回:
    
    true if the specified element occurs within this range
  - isEndedBy
```
public boolean isEndedBy(T element)
```
    Checks whether this range ends with the specified element.
    
    参数:
    
    element - the element to check for, null returns false
    
    返回:
    
    true if the specified element occurs within this range
  - isBefore
```
public boolean isBefore(T element)
```
    Checks whether this range is before the specified element.
    
    参数:
    
    element - the element to check for, null returns false
    
    返回:
    
    true if this range is entirely before the specified element
  - elementCompareTo
```
public int elementCompareTo(T element)
```
    Checks where the specified element occurs relative to this range.
    
    The API is reminiscent of the Comparable interface returning -1 if the element is before the range, 0 if contained within the range and 1 if the element is after the range.
    
    参数:
    
    element - the element to check for, not null
    
    返回:
    
    -1, 0 or +1 depending on the element's location relative to the range
  - containsRange
```
public boolean containsRange(Range<T> otherRange)
```
    Checks whether this range contains all the elements of the specified range.
    
    This method may fail if the ranges have two different comparators or element types.
    
    参数:
    
    otherRange - the range to check, null returns false
    
    返回:
    
    true if this range contains the specified range
    
    抛出:
    
    RuntimeException - if ranges cannot be compared
  - isAfterRange
```
public boolean isAfterRange(Range<T> otherRange)
```
    Checks whether this range is completely after the specified range.
    
    This method may fail if the ranges have two different comparators or element types.
    
    参数:
    
    otherRange - the range to check, null returns false
    
    返回:
    
    true if this range is completely after the specified range
    
    抛出:
    
    RuntimeException - if ranges cannot be compared
  - isOverlappedBy
```
public boolean isOverlappedBy(Range<T> otherRange)
```
    Checks whether this range is overlapped by the specified range.
    
    Two ranges overlap if there is at least one element in common.
    
    This method may fail if the ranges have two different comparators or element types.
    
    参数:
    
    otherRange - the range to test, null returns false
    
    返回:
    
    true if the specified range overlaps with this range; otherwise, false
    
    抛出:
    
    RuntimeException - if ranges cannot be compared
  - isBeforeRange
```
public boolean isBeforeRange(Range<T> otherRange)
```
    Checks whether this range is completely before the specified range.
    
    This method may fail if the ranges have two different comparators or element types.
    
    参数:
    
    otherRange - the range to check, null returns false
    
    返回:
    
    true if this range is completely before the specified range
    
    抛出:
    
    RuntimeException - if ranges cannot be compared
  - intersectionWith
```
public Range<T> intersectionWith(Range<T> other)
```
    Calculate the intersection of this and an overlapping Range.
    
    参数:
    
    other - overlapping Range
    
    返回:
    
    range representing the intersection of this and other (this if equal)
    
    抛出:
    
    IllegalArgumentException - if other does not overlap this
    
    从以下版本开始:
    
    3.0.1
  - equals
```
public boolean equals(Object obj)
```
    Compares this range to another object to test if they are equal.
    .
    To be equal, the minimum and maximum values must be equal, which ignores any differences in the comparator.
    
    覆盖:
    
    equals 在类中 Object
    
    参数:
    
    obj - the reference object with which to compare
    
    返回:
    
    true if this object is equal
  - hashCode
```
public int hashCode()
```
    Gets a suitable hash code for the range.
    
    覆盖:
    
    hashCode 在类中 Object
    
    返回:
    
    a hash code value for this object
  - toString
```
public String toString()
```
    Gets the range as a String.
    
    The format of the String is '[min..max]'.
    
    覆盖:
    
    toString 在类中 Object
    
    返回:
    
    the String representation of this range
  - toString
```
public String toString(String format)
```
    Formats the receiver using the given format.
    
    This uses Formattable to perform the formatting. Three variables may be used to embed the minimum, maximum and comparator. Use %1$s for the minimum element, %2$s for the maximum element and %3$s for the comparator. The default format used by toString() is [%1$s..%2$s].
    
    参数:
    
    format - the format string, optionally containing %1$s, %2$s and %3$s, not null
    
    返回:
    
    the formatted string, not null

类 Range<T>

构造器概要

方法概要

从类继承的方法 java.lang.Object

构造器详细资料

Range

方法详细资料

is

is

between

between

getMinimum

getMaximum

getComparator

isNaturalOrdering

contains

isAfter

isStartedBy

isEndedBy

isBefore

elementCompareTo

containsRange

isAfterRange

isOverlappedBy

isBeforeRange

intersectionWith

equals

hashCode

toString

toString