java.util.TreeSet#tailSet ( )源码实例Demo

/**
 * Return all the elements of the argument that comply with this pattern.
 * <p>
 * This should be functionally equivalent to iterating over every element of
 * the set and checking its compliance, but depending on the composition of
 * this pattern: this method may be faster than if you iterate over all
 * elements directly.
 * 
 * @param set
 * @param string
 * @return
 */
public SortedSet<String> getMatches(TreeSet<String> set) {
	SortedSet<String> returnValue = new TreeSet<>();
	Placeholder[] phs = getPlaceholders();

	StringBuilder constantPrefixBuilder = new StringBuilder();
	for (int a = 0; a < phs.length; a++) {
		if (phs[a] instanceof FixedCharacter) {
			FixedCharacter fc = (FixedCharacter) phs[a];
			constantPrefixBuilder.append(fc.ch);
		} else {
			break;
		}
	}
	String constantPrefix = constantPrefixBuilder.toString();

	for (String s : set.tailSet(constantPrefix, true)) {
		if (matches(s))
			returnValue.add(s);
		if (!s.startsWith(constantPrefix))
			break;
	}

	return returnValue;
}
 

/**
 * Coalate elements that overlap the given interval and return as a linked list.
 */
static <T extends LongInterval> LinkedList<T> getOverlaps(TreeSet<T> set, T interval) {
  LinkedList<T> list = new LinkedList<T>();
  SortedSet<T> subSet = set.headSet(interval);

  // There is only ever one element below the window that can overlap.
  if (!subSet.isEmpty()) {
    T last = subSet.last();
    if (last.getUpper() > interval.getLower()) {
      list.addFirst(last);
    }
  }

  // There are multiple elements that can be above the window start since the set is sorted by
  // just the lower value.
  final long upperLimit = interval.getUpper();
  for (T tmp : set.tailSet(interval)) { // Java 1.5: inclusive of interval
    if (tmp.getLower() < upperLimit) {
      list.add(tmp);
    } else {
      break;
    }
  }
  return list;
}
 

/**
 * tailSet returns set with keys in requested range
 */
public void testTailSetContents() {
    TreeSet set = set5();
    SortedSet sm = set.tailSet(two);
    assertFalse(sm.contains(one));
    assertTrue(sm.contains(two));
    assertTrue(sm.contains(three));
    assertTrue(sm.contains(four));
    assertTrue(sm.contains(five));
    Iterator i = sm.iterator();
    Object k;
    k = (Integer)(i.next());
    assertEquals(two, k);
    k = (Integer)(i.next());
    assertEquals(three, k);
    k = (Integer)(i.next());
    assertEquals(four, k);
    k = (Integer)(i.next());
    assertEquals(five, k);
    assertFalse(i.hasNext());

    SortedSet ssm = sm.tailSet(four);
    assertEquals(four, ssm.first());
    assertEquals(five, ssm.last());
    assertTrue(ssm.remove(four));
    assertEquals(1, ssm.size());
    assertEquals(3, sm.size());
    assertEquals(4, set.size());
}
 

/**
 * Test if the given interval overlaps any element in the set
 * @param set of elements
 * @param interval to test for overlap
 * @return true if overlaps, false otherwise
 */
static <T extends LongInterval> boolean hasOverlapInSet(TreeSet<T> set, T interval) {
  SortedSet<T> subSet = set.headSet(interval);
  if (!subSet.isEmpty() && subSet.last().getUpper() > interval.getLower()) return true;
  subSet = set.tailSet(interval); // Java 1.5: inclusive of interval
  if (!subSet.isEmpty() && subSet.first().getLower() < interval.getUpper()) return true;
  return false;
}
 

/**
 * tailSet returns set with keys in requested range
 */
public void testTailSetContents() {
    TreeSet set = set5();
    SortedSet sm = set.tailSet(two);
    assertFalse(sm.contains(one));
    assertTrue(sm.contains(two));
    assertTrue(sm.contains(three));
    assertTrue(sm.contains(four));
    assertTrue(sm.contains(five));
    Iterator i = sm.iterator();
    Object k;
    k = (Integer)(i.next());
    assertEquals(two, k);
    k = (Integer)(i.next());
    assertEquals(three, k);
    k = (Integer)(i.next());
    assertEquals(four, k);
    k = (Integer)(i.next());
    assertEquals(five, k);
    assertFalse(i.hasNext());

    SortedSet ssm = sm.tailSet(four);
    assertEquals(four, ssm.first());
    assertEquals(five, ssm.last());
    assertTrue(ssm.remove(four));
    assertEquals(1, ssm.size());
    assertEquals(3, sm.size());
    assertEquals(4, set.size());
}
 

/**
 * In this method we'll get the contents within the zip file for the passed directory
 *
 * @param string: Must be a directory within the zip file or an empty string to get the root contents
 */
public List<String> contents(String name) {
    ArrayList<String> ret = new ArrayList<String>();

    int level;
    int length = name.length();
    if (length == 0) {
        level = 0;
    } else {
        Assert.isTrue(StringUtils.endsWith(name, '/')); //must be a directory
        level = StringUtils.count(name, '/');
    }

    TreeSet<String> treeSet = levelToContents.get(level);
    if (treeSet != null) {
        if (length == 0) {
            ret.addAll(treeSet);
        } else {
            for (String s : treeSet.tailSet(name)) {
                if (s.startsWith(name)) {
                    ret.add(s);
                }
            }
        }
    }

    return ret;
}
 

private static NavigableSet set0() {
    TreeSet set = new TreeSet();
    assertTrue(set.isEmpty());
    return set.tailSet(m1, false);
}
 

private static NavigableSet set0() {
    TreeSet set = new TreeSet();
    assertTrue(set.isEmpty());
    return set.tailSet(m1, false);
}
 

@Test(expected = IllegalArgumentException.class)
public void testTailSetTreeSet() {
    TreeSet<Integer> set = new TreeSet<Integer>();

    set.add(1);
    set.add(2);
    set.add(3);
    set.add(4);
    set.add(5);

    SortedSet<Integer> hs = set.tailSet(3);
    hs.add(10);

    assertThat(hs).containsExactly(3, 4, 5, 10);

    set.remove(4);

    assertThat(hs).containsExactly(3, 5, 10);

    set.remove(3);

    assertThat(hs).containsExactly(5, 10);

    hs.add(-1);
}
 

@Test(expected = IllegalArgumentException.class)
public void testTailSetTreeSet() {
    TreeSet<Integer> set = new TreeSet<Integer>();

    set.add(1);
    set.add(2);
    set.add(3);
    set.add(4);
    set.add(5);

    SortedSet<Integer> hs = set.tailSet(3);
    hs.add(10);

    assertThat(hs).containsExactly(3, 4, 5, 10);

    set.remove(4);

    assertThat(hs).containsExactly(3, 5, 10);

    set.remove(3);

    assertThat(hs).containsExactly(5, 10);

    hs.add(-1);
}
 

@Override
public void added(PipelineTimelineEntry newlyAddedEntry, TreeSet<PipelineTimelineEntry> timeline) {
    for (PipelineTimelineEntry pipelineTimelineEntry : timeline.tailSet(newlyAddedEntry)) {
        goCache.remove(key.forFbhOfStagesUnderPipeline(pipelineTimelineEntry.getPipelineLocator()));
    }
}