1. WIKI教程
2. 学习guava
3. guava - 范围类( Range Class)

guava - 范围类( Range Class)

范围表示间隔或序列。 它用于获取位于特定范围内的一组数字/字符串。

Class 声明 (Class Declaration)

以下是com.google.common.collect.Range《C》类的声明 -

@GwtCompatible
public final class Range<C extends Comparable>
   extends Object
      implements Predicate<C>, Serializable

方法 (Methods)

Sr.No	方法和描述
1	static 《C extends Comparable《?》》 Range《C》 all() 返回包含C类型的每个值的范围。
2	boolean apply(C input)Deprecated. 仅提供满足Predicate接口; 使用contains（C）代替。
3	static 《C extends Comparable《?》》 Range《C》 atLeast(C endpoint) 返回包含大于或等于endpoint的所有值的范围。
4	static 《C extends Comparable《?》》 Range《C》 atMost(C endpoint) 返回包含小于或等于endpoint的所有值的范围。
5	Range《C》 canonical(DiscreteDomain《C》 domain) 返回给定域中此范围的规范形式。
6	static 《C extends Comparable《?》》 Range《C》 closed(C lower, C upper) 返回包含大于或等于lower且小于或等于upper的所有值的范围。
7	static 《C extends Comparable《?》》 Range《C》 closedOpen(C lower, C upper) 返回包含大于或等于lower且严格小于upper的所有值的范围。
8	boolean contains(C value) 如果value在此范围的范围内，则返回true。
9	boolean containsAll(Iterable《? extends C》 values) 如果值中的每个元素都包含在此范围内，则返回true。
10	static 《C extends Comparable《?》》 Range《C》 downTo(C endpoint, BoundType boundType) 返回给定端点的范围，该范围可以是包含（闭合）或独占（打开），没有上限。
11	static 《C extends Comparable《?》》 Range《C》 encloseAll(Iterable《C》 values) 返回包含所有给定值的最小范围。
12	boolean encloses(Range《C》 other) 如果其他边界不超出此范围的边界，则返回true。
13	boolean equals(Object object) 如果object是具有与此范围相同的端点和绑定类型的范围，则返回true。
14	static 《C extends Comparable《?》》 Range《C》 greaterThan(C endpoint) 返回包含严格大于endpoint的所有值的范围。
15	int hashCode() 返回此范围的哈希码。
16	boolean hasLowerBound() 如果此范围具有较低的端点，则返回true。
17	boolean hasUpperBound() 如果此范围具有上端点，则返回true。
18	Range《C》 intersection(Range《C》 connectedRange) 如果存在此范围，则返回此范围和connectedRange包含的最大范围。
19	boolean isConnected(Range《C》 other) 如果存在由此范围和其他范围包含的（可能为空）范围，则返回true。
20	boolean isEmpty() 如果此范围的格式为[v..v]或（v..v），则返回true。
21	static 《C extends Comparable《?》》 Range《C》 lessThan(C endpoint) 返回包含严格小于endpoint的所有值的范围。
22	BoundType lowerBoundType() 返回此范围下限的类型:BoundType.CLOSED如果范围包括其下端点，则为BoundType.OPEN（如果不包括）。
23	C lowerEndpoint() 返回此范围的下端点。
24	static 《C extends Comparable《?》》 Range《C》 open(C lower, C upper) 返回一个范围，其中包含严格大于lower且严格小于upper的所有值。
25	static 《C extends Comparable《?》》 Range《C》 openClosed(C lower, C upper) 返回一个范围，其中包含严格大于lower且小于或等于upper的所有值。
26	static 《C extends Comparable《?》》 Range《C》 range(C lower, BoundType lowerType, C upper, BoundType upperType) 返回包含从lower到upper的任何值的范围，其中每个端点可以是包含（闭合）或独占（打开）。
27	static 《C extends Comparable《?》》 Range《C》 singleton(C value) 返回仅包含给定值的范围。
28	Range《C》 span(Range《C》 other) 返回包含此范围和其他范围的最小范围。
29	String toString() 返回此范围的字符串表示形式，例如“[3..5）”（其他示例在类文档中列出）。
30	BoundType upperBoundType() 返回此范围上限的类型:BoundType.CLOSED如果范围包括其上端点，则为BoundType.OPEN（如果不包括）。
31	C upperEndpoint() 返回此范围的上端点。
32	static 《C extends Comparable《?》》 Range《C》 upTo(C endpoint, BoundType boundType) 返回一个没有下限到达给定端点的范围，该范围可以是包含（闭合）或独占（打开）。

方法继承 (Methods Inherited)

该类继承以下类中的方法 -

• java.lang.Object

范围类的示例

使用您选择的任何编辑器在C:/》 Guava.创建以下java程序C:/》 Guava.

GuavaTester.java

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 GuavaTester {
   public static void main(String args[]) {
      GuavaTester tester = new GuavaTester();
      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("]");
   }
}

验证结果

使用javac编译器编译类如下 -

C:\Guava>javac GuavaTester.java

现在运行GuavaTester来查看结果。

C:\Guava>java GuavaTester

看到结果。

[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 ]