Java SortedMap.clear方法代码示例

import java.util.SortedMap; //导入方法依赖的package包/类
public void testTailMapClearThrough() {
  final SortedMap<K, V> map;
  try {
    map = makePopulatedMap();
  } catch (UnsupportedOperationException e) {
    return;
  }
  int oldSize = map.size();
  if (map.size() < 2 || !supportsClear) {
    return;
  }
  Iterator<Entry<K, V>> iterator = map.entrySet().iterator();
  iterator.next(); // advance
  Entry<K, V> secondEntry = iterator.next();
  K key = secondEntry.getKey();
  SortedMap<K, V> subMap = map.tailMap(key);
  int subMapSize = subMap.size();
  subMap.clear();
  assertEquals(map.size(), oldSize - subMapSize);
  assertTrue(subMap.isEmpty());
}
 

import java.util.SortedMap; //导入方法依赖的package包/类
public void testSubRowClearAndPut() {
  table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
  SortedMap<Integer, Character> row = (SortedMap<Integer, Character>) table.row("foo");
  SortedMap<Integer, Character> subRow = row.tailMap(2);
  assertEquals(ImmutableMap.of(1, 'a', 3, 'c'), row);
  assertEquals(ImmutableMap.of(3, 'c'), subRow);
  table.remove("foo", 3);
  assertEquals(ImmutableMap.of(1, 'a'), row);
  assertEquals(ImmutableMap.of(), subRow);
  table.remove("foo", 1);
  assertEquals(ImmutableMap.of(), row);
  assertEquals(ImmutableMap.of(), subRow);
  table.put("foo", 2, 'b');
  assertEquals(ImmutableMap.of(2, 'b'), row);
  assertEquals(ImmutableMap.of(2, 'b'), subRow);
  row.clear();
  assertEquals(ImmutableMap.of(), row);
  assertEquals(ImmutableMap.of(), subRow);
  table.put("foo", 5, 'x');
  assertEquals(ImmutableMap.of(5, 'x'), row);
  assertEquals(ImmutableMap.of(5, 'x'), subRow);
}
 

import java.util.SortedMap; //导入方法依赖的package包/类
/**
 * headMap returns map with keys in requested range
 */
public void testHeadMapContents() {
    ConcurrentNavigableMap map = map5();
    SortedMap sm = map.headMap(four);
    assertTrue(sm.containsKey(one));
    assertTrue(sm.containsKey(two));
    assertTrue(sm.containsKey(three));
    assertFalse(sm.containsKey(four));
    assertFalse(sm.containsKey(five));
    Iterator i = sm.keySet().iterator();
    Object k;
    k = (Integer)(i.next());
    assertEquals(one, k);
    k = (Integer)(i.next());
    assertEquals(two, k);
    k = (Integer)(i.next());
    assertEquals(three, k);
    assertFalse(i.hasNext());
    sm.clear();
    assertTrue(sm.isEmpty());
    assertEquals(2, map.size());
    assertEquals(four, map.firstKey());
}
 

import java.util.SortedMap; //导入方法依赖的package包/类
/**
 * headMap returns map with keys in requested range
 */
public void testDescendingHeadMapContents() {
    ConcurrentNavigableMap map = dmap5();
    SortedMap sm = map.headMap(m4);
    assertTrue(sm.containsKey(m1));
    assertTrue(sm.containsKey(m2));
    assertTrue(sm.containsKey(m3));
    assertFalse(sm.containsKey(m4));
    assertFalse(sm.containsKey(m5));
    Iterator i = sm.keySet().iterator();
    Object k;
    k = (Integer)(i.next());
    assertEquals(m1, k);
    k = (Integer)(i.next());
    assertEquals(m2, k);
    k = (Integer)(i.next());
    assertEquals(m3, k);
    assertFalse(i.hasNext());
    sm.clear();
    assertTrue(sm.isEmpty());
    assertEquals(2, map.size());
    assertEquals(m4, map.firstKey());
}
 

import java.util.SortedMap; //导入方法依赖的package包/类
/**
 * headMap returns map with keys in requested range
 */
public void testHeadMapContents() {
    NavigableMap map = map5();
    SortedMap sm = map.headMap(four);
    assertTrue(sm.containsKey(one));
    assertTrue(sm.containsKey(two));
    assertTrue(sm.containsKey(three));
    assertFalse(sm.containsKey(four));
    assertFalse(sm.containsKey(five));
    Iterator i = sm.keySet().iterator();
    Object k;
    k = (Integer)(i.next());
    assertEquals(one, k);
    k = (Integer)(i.next());
    assertEquals(two, k);
    k = (Integer)(i.next());
    assertEquals(three, k);
    assertFalse(i.hasNext());
    sm.clear();
    assertTrue(sm.isEmpty());
    assertEquals(2, map.size());
    assertEquals(four, map.firstKey());
}
 

import java.util.SortedMap; //导入方法依赖的package包/类
/**
 * headMap returns map with keys in requested range
 */
public void testDescendingHeadMapContents() {
    NavigableMap map = dmap5();
    SortedMap sm = map.headMap(m4);
    assertTrue(sm.containsKey(m1));
    assertTrue(sm.containsKey(m2));
    assertTrue(sm.containsKey(m3));
    assertFalse(sm.containsKey(m4));
    assertFalse(sm.containsKey(m5));
    Iterator i = sm.keySet().iterator();
    Object k;
    k = (Integer)(i.next());
    assertEquals(m1, k);
    k = (Integer)(i.next());
    assertEquals(m2, k);
    k = (Integer)(i.next());
    assertEquals(m3, k);
    assertFalse(i.hasNext());
    sm.clear();
    assertTrue(sm.isEmpty());
    assertEquals(2, map.size());
    assertEquals(m4, map.firstKey());
}
 

import java.util.SortedMap; //导入方法依赖的package包/类
/**
 * Reads a stored mapped from the JSON object and populates the data
 * structure
 * 
 * @param <U>
 * @param <V>
 * @param map
 * @param name
 * @param key_map
 * @param object
 * @throws JSONException
 */
@SuppressWarnings("unchecked")
protected <U, V> void readMap(SortedMap<U, V> map, String name, Map<String, U> key_map, Class<?> value_class, JSONObject object) throws JSONException {
    map.clear();
    JSONObject jsonObject = object.getJSONObject(name);
    Iterator<String> keys = jsonObject.keys();
    boolean first = true;
    while (keys.hasNext()) {
        String key_name = keys.next();
        U key_object = null;
        V value = null;

        if (value_class.equals(Long.class)) {
            value = (V) new Long(jsonObject.getLong(key_name));
        } else {
            value = (V) jsonObject.get(key_name);
        }
        key_object = key_map.get(key_name);
        if (key_object == null) {
            LOG.warn("Failed to retrieve key object '" + key_name + "' for " + name);
            if (LOG.isDebugEnabled() && first) {
                LOG.warn(jsonObject.toString(2));
            }
            first = false;
            continue;
        }
        map.put(key_object, value);
    } // FOR
    LOG.debug("Added " + map.size() + " values to " + name);
    return;
}
 

import java.util.SortedMap; //导入方法依赖的package包/类
public boolean append(@Nonnull AppendEntries appendEntries) {

        final long prevLogIndex = appendEntries.getPrevLogIndex();
        final long prevLogTerm = appendEntries.getPrevLogTerm();
        final List<Entry> entries = appendEntries.getEntriesList();

        EntryMeta previousEntry = entryIndex.get(prevLogIndex);
        if ((previousEntry == null) || (previousEntry.term != prevLogTerm)) {
            LOGGER.debug("Append prevLogIndex {} prevLogTerm {} previousEntry {}", prevLogIndex, prevLogTerm, previousEntry);
            return false;
        }

        SortedMap<Long, EntryMeta> old = this.entryIndex.tailMap(prevLogIndex + 1);
        for (EntryMeta e : old.values()) {
            try {
                LOGGER.debug("Deleting {}", e.index);
                journal.delete(e.location);
            } catch (IOException e1) {
                e1.printStackTrace();
            }
        }
        old.clear();
        lastLogIndex = prevLogIndex;

        for (Entry entry : entries) {
            storeEntry(++lastLogIndex, entry);
        }

        return true;

    }