Guava学习——Range类

Range表示一个间隔或者一个序列。它别用于获取一组数字/串在一个特定的范围内（开闭区间）

//类的声明
@GwtCompatible
public final class Range<C extends Comparable>
   extends Object
      implements Predicate<C>, Serializable

几个好用的方法

//返回包含大于或等于终点(endpoint)的所有值的范围内
static <C extends Comparable<?>> Range<C> atLeast(C endpoint)

//返回包含的所有值小于或等于终点的范围内。  static <C extends Comparable<?>> Range<C> atMost(C endpoint)

//返回此范围内，在给定域中的规范形式。    Range<C> canonical(DiscreteDomain<C> domain)

//返回包含大于所有值或等于降低且小于或等于上限的范围内。   static <C extends Comparable<?>> Range<C> closed(C lower, C upper)

//返回包含只在给定范围内的值
static <C extends Comparable<?>> Range<C> singleton(C value)


//返回包含大于或等于下限和所有值严格大于上限以下的范围内。  static <C extends Comparable<?>> Range<C> closedOpen(C lower, C upper)

//返回的范围内的给定的端点，它可以是包容性（闭合）或专用（开），没有上限。  static <C extends Comparable<?>> Range<C> downTo(C endpoint, BoundType boundType)

//返回包含所有给定值的最小范围内
static <C extends Comparable<?>> Range<C> encloseAll(Iterable<C> values)

//返回true，如果值是这个范围的范围之内
boolean contains(C value)

//如果值每一个元素都包含在这个范围内，则返回 true
boolean containsAll(Iterable<? extends C> values)

//如果此范围内具有更低的终点返回true。
boolean hasLowerBound()

//如果此范围内有上端点返回true。
boolean hasUpperBound()

//返回由两者范围和connectedRange封闭，如果这样的范围存在的最大范围（交集）
Range<C> intersection(Range<C> connectedRange)

//如果存在这是由两者此范围和其他封闭（可能为空）的范围，则返回true。（连着的）
boolean isConnected(Range<C> other)

//返回类型这个范围的下限：如果范围包括它的下端点BoundType.CLOSED，如果没有BoundType.OPEN
BoundType lowerBoundType()

//返回该范围的较低端点
    C lowerEndpoint()

//返回此范围的上限端点。
C upperEndpoint()

测试

package guavaDome;

import com.google.common.collect.ContiguousSet;
import com.google.common.collect.DiscreteDomain;
import com.google.common.collect.Range;
import com.google.common.primitives.Ints;

public class RangeDome {
    public static void main(String args[]) {
        RangeDome tester = new RangeDome();
        tester.testRange();
    }

    private void testRange() {

        // create a range [a,b] = { x | a <= x <= b}
        Range<Integer> range1 = Range.closed(0, 9);
        System.out.print("[0,9] : ");
        //输出函数
        printRange(range1);
        System.out.println("5 is present: " + range1.contains(5));
        System.out.println("(1,2,3) is present: " + range1.containsAll(Ints.asList(1, 2, 3)));
        System.out.println("Lower Bound: " + range1.lowerEndpoint());
        System.out.println("Upper Bound: " + range1.upperEndpoint());

        // create a range (a,b) = { x | a < x < b}
        Range<Integer> range2 = Range.open(0, 9);
        System.out.print("(0,9) : ");
        printRange(range2);

        // create a range (a,b] = { x | a < x <= b}
        Range<Integer> range3 = Range.openClosed(0, 9);
        System.out.print("(0,9] : ");
        printRange(range3);

        // create a range [a,b) = { x | a <= x < b}
        Range<Integer> range4 = Range.closedOpen(0, 9);
        System.out.print("[0,9) : ");
        printRange(range4);

        // create an open ended range (9, infinity
        Range<Integer> range5 = Range.greaterThan(9);
        System.out.println("(9,infinity) : ");
        System.out.println("Lower Bound: " + range5.lowerEndpoint());
        System.out.println("Upper Bound present: " + range5.hasUpperBound());

        Range<Integer> range6 = Range.closed(3, 5);
        printRange(range6);

        // check a subrange [3,5] in [0,9]
        System.out.println("[0,9] encloses [3,5]:" + range1.encloses(range6));

        Range<Integer> range7 = Range.closed(9, 20);
        printRange(range7);
        // check ranges to be connected
        System.out.println("[0,9] is connected [9,20]:" + range1.isConnected(range7));

        Range<Integer> range8 = Range.closed(5, 15);

        // intersection
        printRange(range1.intersection(range8));

        // span
        printRange(range1.span(range8));
    }

    private void printRange(Range<Integer> range) {
        System.out.print("[ ");
        for (int grade : ContiguousSet.create(range, DiscreteDomain.integers())) {
            System.out.print(grade + " ");
        }
        System.out.println("]");
    }
}

测试结果

[0,9] : [ 0 1 2 3 4 5 6 7 8 9 ]
5 is present: true
(1,2,3) is present: true
Lower Bound: 0
Upper Bound: 9
(0,9) : [ 1 2 3 4 5 6 7 8 ]
(0,9] : [ 1 2 3 4 5 6 7 8 9 ]
[0,9) : [ 0 1 2 3 4 5 6 7 8 ]
(9,infinity) : 
Lower Bound: 9
Upper Bound present: false
[ 3 4 5 ]
[0,9] encloses [3,5]:true
[ 9 10 11 12 13 14 15 16 17 18 19 20 ]
[0,9] is connected [9,20]:true
[ 5 6 7 8 9 ]
[ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 ]