Java NavigableSet类代码示例

import java.util.NavigableSet; //导入依赖的package包/类
@Test(dataProvider = "NavigableSet<?>", dataProviderClass = EmptyNavigableSet.class)
public void testheadSetRanges(String description, NavigableSet navigableSet) {
    NavigableSet subSet = navigableSet.headSet(BigInteger.ONE, true);

    // same subset
    subSet.headSet(BigInteger.ONE, true);

    // slightly smaller
    NavigableSet ns = subSet.headSet(BigInteger.ONE, false);

    // slight expansion
    assertThrowsIAE(() -> {
        ns.headSet(BigInteger.ONE, true);
    },
        description + ": Expansion should not be allowed");

    // much smaller
    subSet.headSet(isDescending(subSet) ? BigInteger.TEN : BigInteger.ZERO, true);
}
 

import java.util.NavigableSet; //导入依赖的package包/类
/**
 * descending iterator of descendingKeySet is ordered
 */
public void testDescendingKeySetDescendingIteratorOrder() {
    TreeMap map = map5();
    NavigableSet s = map.descendingKeySet();
    Iterator i = s.descendingIterator();
    Integer last = (Integer)i.next();
    assertEquals(last, one);
    int count = 1;
    while (i.hasNext()) {
        Integer k = (Integer)i.next();
        assertTrue(last.compareTo(k) < 0);
        last = k;
        ++count;
    }
    assertEquals(5, count);
}
 

import java.util.NavigableSet; //导入依赖的package包/类
public void testNavigableSubSet() {
  for (List<Integer> contents : SAMPLE_INPUTS) {
    for (int i = 0; i < 10; i++) {
      for (int j = i + 1; j < 10; j++) {
        for (boolean fromInclusive : ImmutableList.of(true, false)) {
          for (boolean toInclusive : ImmutableList.of(true, false)) {
            NavigableSet<Integer> filterSubset = filter(
                createUnfiltered(contents).subSet(i, fromInclusive, j, toInclusive), EVEN);
            NavigableSet<Integer> subsetFilter = filter(createUnfiltered(contents), EVEN)
                .subSet(i, fromInclusive, j, toInclusive);
            assertEquals(filterSubset, subsetFilter);
          }
        }
      }
    }
  }
}
 

import java.util.NavigableSet; //导入依赖的package包/类
/**
 * iterator.remove removes current element
 */
public void testIteratorRemove() {
    final NavigableSet q = set0();
    q.add(new Integer(2));
    q.add(new Integer(1));
    q.add(new Integer(3));

    Iterator it = q.iterator();
    it.next();
    it.remove();

    it = q.iterator();
    assertEquals(it.next(), new Integer(2));
    assertEquals(it.next(), new Integer(3));
    assertFalse(it.hasNext());
}
 

import java.util.NavigableSet; //导入依赖的package包/类
/**
 * iterator iterates through all elements
 */
public void testDescendingIterator() {
    NavigableSet q = populatedSet(SIZE);
    int i = 0;
    Iterator it = q.iterator();
    while (it.hasNext()) {
        assertTrue(q.contains(it.next()));
        ++i;
    }
    assertEquals(i, SIZE);
}
 

import java.util.NavigableSet; //导入依赖的package包/类
/**
 * Get the column from the specified family with the specified qualifier.
 * <p>
 * Overrides previous calls to addFamily for this family.
 * @param family family name
 * @param qualifier column qualifier
 * @return this
 */
public Scan addColumn(byte [] family, byte [] qualifier) {
  NavigableSet<byte []> set = familyMap.get(family);
  if(set == null) {
    set = new TreeSet<byte []>(Bytes.BYTES_COMPARATOR);
  }
  if (qualifier == null) {
    qualifier = HConstants.EMPTY_BYTE_ARRAY;
  }
  set.add(qualifier);
  familyMap.put(family, set);
  return this;
}
 

import java.util.NavigableSet; //导入依赖的package包/类
/**
 * containsAll(c) is true when c contains a subset of elements
 */
public void testContainsAll() {
    NavigableSet q = populatedSet(SIZE);
    NavigableSet p = set0();
    for (int i = 0; i < SIZE; ++i) {
        assertTrue(q.containsAll(p));
        assertFalse(p.containsAll(q));
        p.add(new Integer(i));
    }
    assertTrue(p.containsAll(q));
}
 

import java.util.NavigableSet; //导入依赖的package包/类
public void testPollFirst() {
  for (List<Integer> contents : SAMPLE_INPUTS) {
    NavigableSet<Integer> filtered = filter(createUnfiltered(contents), EVEN);
    NavigableSet<Integer> unfiltered = createUnfiltered(filtered);

    assertEquals(unfiltered.pollFirst(), filtered.pollFirst());
    assertEquals(unfiltered, filtered);
  }
}
 

import java.util.NavigableSet; //导入依赖的package包/类
/**
 * A sensible definition of {@link #subSet(Object, boolean, Object, boolean)} in terms of the
 * {@code headSet} and {@code tailSet} methods. In many cases, you may wish to override
 * {@link #subSet(Object, boolean, Object, boolean)} to forward to this implementation.
 */
@Beta
protected NavigableSet<E> standardSubSet(
    E fromElement,
    boolean fromInclusive,
    E toElement,
    boolean toInclusive) {
  return tailSet(fromElement, fromInclusive).headSet(toElement, toInclusive);
}
 

import java.util.NavigableSet; //导入依赖的package包/类
private static void demoNavigableSetRemove(NavigableSet<Integer> set) {
    System.out.println("set: " + set);
    try {
        for (int i : set) {
            System.out.println(i);
            System.out.println("Calling set.remove(2)...");
            set.remove(2);
        }
    } catch (Exception ex) {
        System.out.println(ex.getClass().getName());
    }
    System.out.println("set: " + set);
}
 

import java.util.NavigableSet; //导入依赖的package包/类
private void removeMonitors(long limit) {
    Consumer<ClusterAddress> doRemove = node -> {
        if (DEBUG) {
            log.debug("Stopped monitoring [node={}]", node);
        }

        monitors.remove(node);
    };

    NavigableSet<ClusterAddress> allSorted = new TreeSet<>(allNodes);

    // Nodes that are before the local node in the ring.
    List<ClusterAddress> toRemove = allSorted.headSet(localNode, false).stream()
        .filter(monitors::containsKey)
        .limit(limit)
        .collect(toList());

    toRemove.forEach(doRemove);

    long removeMore = limit - toRemove.size();

    if (removeMore > 0) {
        allSorted.tailSet(localNode, false).stream()
            .filter(monitors::containsKey)
            .limit(limit)
            .forEach(doRemove);
    }
}
 

import java.util.NavigableSet; //导入依赖的package包/类
@Test
public void testToSubchartsDeep() throws IOException {
  final String input = "wordpress/charts/mariadb/charts/frobnicator/templates/foo.yaml";
  final NavigableSet<String> output = StreamOrientedChartLoader.toSubcharts(input);
  assertNotNull(output);
  assertEquals(2, output.size());
  assertEquals("wordpress/charts/mariadb", output.first());
  assertEquals("wordpress/charts/mariadb/charts/frobnicator", output.last());
      
}
 

import java.util.NavigableSet; //导入依赖的package包/类
@SuppressWarnings("unchecked")
protected <E> NavigableSet<E> create() {
  TestSet<E> inner =
      new TestSet<E>(new TreeSet<E>((Comparator<E>) Ordering.natural().nullsFirst()), null);
  NavigableSet<E> outer = Synchronized.navigableSet(inner, null);
  inner.mutex = outer;
  return outer;
}
 

import java.util.NavigableSet; //导入依赖的package包/类
@Override
public NavigableSet<E> subSet(
    E fromElement,
    boolean fromInclusive,
    E toElement,
    boolean toInclusive) {
  return unmodifiableNavigableSet(delegate.subSet(
      fromElement,
      fromInclusive,
      toElement,
      toInclusive));
}
 

import java.util.NavigableSet; //导入依赖的package包/类
private Cell getNextRow(final Cell key,
    final NavigableSet<Cell> set) {
  Cell result = null;
  SortedSet<Cell> tail = key == null? set: set.tailSet(key);
  // Iterate until we fall into the next row; i.e. move off current row
  for (Cell cell: tail) {
    if (comparator.compareRows(cell, key) <= 0)
      continue;
    // Note: Not suppressing deletes or expired cells.  Needs to be handled
    // by higher up functions.
    result = cell;
    break;
  }
  return result;
}