java.util.Collections.emptyNavigableMap java code examples

Add the Codota plugin to your IDE and get smart completions

private void myMethod () {
 LocalDateTime l =new LocalDateTime()
LocalDateTime.now()
DateTimeFormatter formatter;String text;formatter.parseLocalDateTime(text)
Smart code suggestions by Tabnine
}

 @Override
 protected NavigableMap<String, String> create(Entry<String, String>[] entries) {
  return Collections.emptyNavigableMap();
 }
})

classes.add(Collections.checkedList(nonRandomAccessList, Void.class).getClass());
classes.add(Collections.checkedMap(Collections.emptyMap(), Void.class, Void.class).getClass());
classes.add(Collections.checkedNavigableMap(Collections.emptyNavigableMap(), Void.class, Void.class).getClass());
classes.add(Collections.checkedNavigableSet(Collections.emptyNavigableSet(), Void.class).getClass());
classes.add(Collections.checkedQueue(new LinkedList<>(), Void.class).getClass());
classes.add(Collections.synchronizedList(nonRandomAccessList).getClass());
classes.add(Collections.synchronizedMap(Collections.emptyMap()).getClass());
classes.add(Collections.synchronizedNavigableMap(Collections.emptyNavigableMap()).getClass());
classes.add(Collections.synchronizedNavigableSet(Collections.emptyNavigableSet()).getClass());
classes.add(Collections.synchronizedSet(Collections.emptySet()).getClass());
classes.add(Collections.unmodifiableList(nonRandomAccessList).getClass());
classes.add(Collections.unmodifiableMap(Collections.emptyMap()).getClass());
classes.add(Collections.unmodifiableNavigableMap(Collections.emptyNavigableMap()).getClass());
classes.add(Collections.unmodifiableNavigableSet(Collections.emptyNavigableSet()).getClass());
classes.add(Collections.unmodifiableSet(Collections.emptySet()).getClass());

assertTrue(immutability.test(Collections.emptyListIterator()));
assertTrue(immutability.test(Collections.emptyMap()));
assertTrue(immutability.test(Collections.emptyNavigableMap()));
assertTrue(immutability.test(Collections.emptyNavigableSet()));
assertTrue(immutability.test(Collections.emptySet()));

 @Override
 protected NavigableMap<String, String> create(Entry<String, String>[] entries) {
  return Collections.emptyNavigableMap();
 }
})

  /**
   * @param <I> The {@link KeyTypeIndicator}
   * @param indicators The indicators to group
   * @return A {@link NavigableMap} where key=the case <U>insensitive</U> {@link #getKeyType() key type},
   * value = the {@link List} of all indicators having the same key type
   */
  static <I extends KeyTypeIndicator> NavigableMap<String, List<I>> groupByKeyType(Collection<? extends I> indicators) {
    return GenericUtils.isEmpty(indicators)
       ? Collections.emptyNavigableMap()
       : indicators.stream()
         .collect(Collectors.groupingBy(
           KeyTypeIndicator::getKeyType, () -> new TreeMap<>(String.CASE_INSENSITIVE_ORDER), Collectors.toList()));
  }
}

protected static NavigableMap<String, byte[]> getMapReadOnly(final MapDBTransaction tx, final String mapName) {
  checkNotNull(tx, "Precondition violation - argument 'tx' must not be NULL!");
  checkNotNull(mapName, "Precondition violation - argument 'mapName' must not be NULL!");
  if (tx.exists(mapName) == false) {
    return Collections.emptyNavigableMap();
  } else {
    return tx.treeMap(mapName, Serializer.STRING, Serializer.BYTE_ARRAY);
  }
}

protected static NavigableMap<String, Boolean> getMapInverseReadOnly(final MapDBTransaction tx,
    final String mapName) {
  checkNotNull(tx, "Precondition violation - argument 'tx' must not be NULL!");
  checkNotNull(mapName, "Precondition violation - argument 'mapName' must not be NULL!");
  String inverseMapName = mapName + INVERSE_MATRIX_SUFFIX;
  if (tx.exists(inverseMapName) == false) {
    return Collections.emptyNavigableMap();
  } else {
    return tx.treeMap(inverseMapName, Serializer.STRING, Serializer.BOOLEAN);
  }
}

public static NavigableMap<String, String> toStringExtensions(Map<String, ?> extensions) {
  if (GenericUtils.isEmpty(extensions)) {
    return Collections.emptyNavigableMap();
  }
  // NOTE: even though extensions are probably case sensitive we do not allow duplicate name that differs only in case
  NavigableMap<String, String> map = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
  extensions.forEach((key, value) -> {
    ValidateUtils.checkNotNull(value, "No value for extension=%s", key);
    String prev = map.put(key, (value instanceof byte[]) ? new String((byte[]) value, StandardCharsets.UTF_8) : value.toString());
    ValidateUtils.checkTrue(prev == null, "Multiple values for extension=%s", key);
  });
  return map;
}

public static NavigableMap<String, byte[]> toBinaryExtensions(Map<String, String> extensions) {
  if (GenericUtils.isEmpty(extensions)) {
    return Collections.emptyNavigableMap();
  }
  // NOTE: even though extensions are probably case sensitive we do not allow duplicate name that differs only in case
  NavigableMap<String, byte[]> map = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
  extensions.forEach((key, value) -> {
    ValidateUtils.checkNotNull(value, "No value for extension=%s", key);
    byte[] prev = map.put(key, value.getBytes(StandardCharsets.UTF_8));
    ValidateUtils.checkTrue(prev == null, "Multiple values for extension=%s", key);
  });
  return map;
}

/**
 * @return A snapshot of the currently registered specialized {@link PublicKeyEntryDataResolver}-s,
 * where key=the key-type value (case <U>insensitive</U>) - e.g., &quot;ssh-rsa&quot;,
 * &quot;pgp-sign-dss&quot;, etc., value=the associated {@link PublicKeyEntryDataResolver}
 * for the key type
 */
public static NavigableMap<String, PublicKeyEntryDataResolver> getRegisteredKeyDataEntryResolvers() {
  NavigableMap<String, PublicKeyEntryDataResolver> decoders;
  synchronized (KEY_DATA_RESOLVERS) {
    if (KEY_DATA_RESOLVERS.isEmpty()) {
      return Collections.emptyNavigableMap();
    }
    decoders = new TreeMap<>(KEY_DATA_RESOLVERS.comparator());
    decoders.putAll(KEY_DATA_RESOLVERS);
  }
  return decoders;
}

protected NavigableMap<String, Object> readFileAttributes(Path file, String view, LinkOption... options) throws IOException {
  try {
    Map<String, ?> attrs = Files.readAttributes(file, view, options);
    if (GenericUtils.isEmpty(attrs)) {
      return Collections.emptyNavigableMap();
    }
    NavigableMap<String, Object> sorted = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
    sorted.putAll(attrs);
    return sorted;
  } catch (IOException e) {
    return handleReadFileAttributesException(file, view, options, e);
  }
}

private NavigableMap<Long, byte[]> getMapForReading(final MapDBTransaction tx) {
  checkNotNull(tx, "Precondition violation - argument 'tx' must not be NULL!");
  String mapName = this.getBranchName() + MAP_SUFFIX;
  if (tx.exists(mapName)) {
    return Collections.unmodifiableNavigableMap(tx.treeMap(mapName, Serializer.LONG, Serializer.BYTE_ARRAY));
  } else {
    return Collections.emptyNavigableMap();
  }
}

@Override
public NavigableMap<Long, ReceivedMessage> getMessages(MessageStatus status) {
  switch(status) {
  case CREATED:
    return Collections.unmodifiableNavigableMap(messages.unreadMessages);
  case READ:
    return Collections.unmodifiableNavigableMap(messages.readMessages);
  case DELETED:
    return Collections.unmodifiableNavigableMap(messages.deletedMessages);
  default: 
    return Collections.emptyNavigableMap();
  }
}

/**
 * @param subKeys The {@link Subkey}-s to map - ignored if {@code null}/empty
 * @return A {@link NavigableMap} where key=the (case <U>insensitive</U>) fingerprint
 * value, value=the matching {@link Subkey}
 * @throws NullPointerException If key with {@code null} fingerprint encountered
 * @throws IllegalArgumentException If key with empty fingerprint encountered
 * @throws IllegalStateException If more than one key with same fingerprint found
 */
public static NavigableMap<String, Subkey> mapSubKeysByFingerprint(Collection<? extends Subkey> subKeys) {
  if (GenericUtils.isEmpty(subKeys)) {
    return Collections.emptyNavigableMap();
  }
  NavigableMap<String, Subkey> keysMap = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
  for (Subkey sk : subKeys) {
    String fp = ValidateUtils.checkNotNullAndNotEmpty(sk.getFingerprint(), "No fingerprint for %s", sk);
    Subkey prev = keysMap.put(fp, sk);
    ValidateUtils.checkState(prev == null, "Multiple sub-keys with fingerprint=%s: %s / %s", fp, sk, prev);
  }
  return keysMap;
}

private NavigableMap<Long, ReceivedMessage> getMessages(long tm, MessageStatus status) {
  switch(status) {
  case SENT:
    return Collections.unmodifiableNavigableMap(messages.unreadMessages.tailMap(tm));
  case READ:
    return Collections.unmodifiableNavigableMap(messages.readMessages.tailMap(tm));
  case DELETED:
    return Collections.unmodifiableNavigableMap(messages.deletedMessages.tailMap(tm));
  default: 
    return Collections.emptyNavigableMap();
  }
}

@Test
public void readPost111() throws IOException {
  String prefix = "post-1.1.1-";
  assertCollectionEqualAndUsable(Collections.emptyList(), readFileAndDeserialize(prefix + "emptyList"));
  assertCollectionEqualAndUsable(Arrays.asList("test"), readFileAndDeserialize(prefix + "asList"));
  assertCollectionEqualAndUsable(Collections.emptyMap(), readFileAndDeserialize(prefix + "emptyMap"));
  assertCollectionEqualAndUsable(Collections.emptyNavigableMap(),
      readFileAndDeserialize(prefix + "emptyNavigableMap"));
  assertCollectionEqualAndUsable(Collections.emptySortedMap(), readFileAndDeserialize(prefix + "emptySortedMap"));
  assertCollectionEqualAndUsable(Collections.emptySet(), readFileAndDeserialize(prefix + "emptySet"));
  assertCollectionEqualAndUsable(Collections.emptyNavigableSet(),
      readFileAndDeserialize(prefix + "emptyNavigableSet"));
  assertCollectionEqualAndUsable(Collections.emptySortedSet(), readFileAndDeserialize(prefix + "emptySortedSet"));
  assertCollectionEqualAndUsable(Collections.singleton("test"), readFileAndDeserialize(prefix + "singletonSet"));
  assertCollectionEqualAndUsable(Collections.singletonList("test"),
      readFileAndDeserialize(prefix + "singletonList"));
  assertCollectionEqualAndUsable(Collections.singletonMap("k", "v"),
      readFileAndDeserialize(prefix + "singletonMap"));
}

@Test
public void testEmptyCollectionClone() {
  Object target;
  target = Collections.emptyList();
  assertCollectionEqualAndUsable(target, cloneWithKryo(target));
  target = Collections.emptySet();
  assertCollectionEqualAndUsable(target, cloneWithKryo(target));
  target = Collections.emptyMap();
  assertCollectionEqualAndUsable(target, cloneWithKryo(target));
  target = Collections.emptyNavigableMap();
  assertCollectionEqualAndUsable(target, cloneWithKryo(target));
  target = Collections.emptyNavigableSet();
  assertCollectionEqualAndUsable(target, cloneWithKryo(target));
  target = Collections.emptySortedMap();
  assertCollectionEqualAndUsable(target, cloneWithKryo(target));
  target = Collections.emptySortedSet();
  assertCollectionEqualAndUsable(target, cloneWithKryo(target));
}

@Test
public void testEmptyCollectionSerialization() {
  Object target;
  target = Collections.emptyList();
  assertCollectionEqualAndUsable(target, serAndDeser(target));
  target = Collections.emptySet();
  assertCollectionEqualAndUsable(target, serAndDeser(target));
  target = Collections.emptyMap();
  assertCollectionEqualAndUsable(target, serAndDeser(target));
  target = Collections.emptyNavigableMap();
  assertCollectionEqualAndUsable(target, serAndDeser(target));
  target = Collections.emptyNavigableSet();
  assertCollectionEqualAndUsable(target, serAndDeser(target));
  target = Collections.emptySortedMap();
  assertCollectionEqualAndUsable(target, serAndDeser(target));
  target = Collections.emptySortedSet();
  assertCollectionEqualAndUsable(target, serAndDeser(target));
}

@Test
public void testEmptyCollectionSerialization() {
  Object target;
  target = Collections.emptyList();
  assertCollectionEqualAndUsable(target, serAndDeser(target));
  target = Collections.emptySet();
  assertCollectionEqualAndUsable(target, serAndDeser(target));
  target = Collections.emptyMap();
  assertCollectionEqualAndUsable(target, serAndDeser(target));
  target = Collections.emptyNavigableMap();
  assertCollectionEqualAndUsable(target, serAndDeser(target));
  target = Collections.emptyNavigableSet();
  assertCollectionEqualAndUsable(target, serAndDeser(target));
  target = Collections.emptySortedMap();
  assertCollectionEqualAndUsable(target, serAndDeser(target));
  target = Collections.emptySortedSet();
  assertCollectionEqualAndUsable(target, serAndDeser(target));
}

@Test
public void testEmptyCollectionClone() {
  Object target;
  target = Collections.emptyList();
  assertCollectionEqualAndUsable(target, cloneWithKryo(target));
  target = Collections.emptySet();
  assertCollectionEqualAndUsable(target, cloneWithKryo(target));
  target = Collections.emptyMap();
  assertCollectionEqualAndUsable(target, cloneWithKryo(target));
  target = Collections.emptyNavigableMap();
  assertCollectionEqualAndUsable(target, cloneWithKryo(target));
  target = Collections.emptyNavigableSet();
  assertCollectionEqualAndUsable(target, cloneWithKryo(target));
  target = Collections.emptySortedMap();
  assertCollectionEqualAndUsable(target, cloneWithKryo(target));
  target = Collections.emptySortedSet();
  assertCollectionEqualAndUsable(target, cloneWithKryo(target));
}

Popular methods of Collections

emptyList
Returns the empty list (immutable). This list is serializable.This example illustrates the type-safe
sort
singletonList
Returns an immutable list containing only the specified object. The returned list is serializable.
unmodifiableList
Returns an unmodifiable view of the specified list. This method allows modules to provide users with
emptyMap
Returns the empty map (immutable). This map is serializable.This example illustrates the type-safe w
emptySet
Returns the empty set (immutable). This set is serializable. Unlike the like-named field, this metho
unmodifiableMap
Returns an unmodifiable view of the specified map. This method allows modules to provide users with
singleton
Returns an immutable set containing only the specified object. The returned set is serializable.
unmodifiableSet
Returns an unmodifiable view of the specified set. This method allows modules to provide users with
singletonMap
Returns an immutable map, mapping only the specified key to the specified value. The returned map is
addAll
Adds all of the specified elements to the specified collection. Elements to be added may be specifie
reverse
Reverses the order of the elements in the specified list. This method runs in linear time.

Popular in Java

Making http requests using okhttp
getResourceAsStream (ClassLoader)
putExtra (Intent)
setContentView (Activity)
BufferedReader (java.io)
Wraps an existing Reader and buffers the input. Expensive interaction with the underlying reader is
BufferedWriter (java.io)
Wraps an existing Writer and buffers the output. Expensive interaction with the underlying reader is
Format (java.text)
The base class for all formats. This is an abstract base class which specifies the protocol for clas
Properties (java.util)
A Properties object is a Hashtable where the keys and values must be Strings. Each property can have
Set (java.util)
A Set is a data structure which does not allow duplicate elements.
TimerTask (java.util)
The TimerTask class represents a task to run at a specified time. The task may be run once or repeat

How to use emptyNavigableMapmethodin java.util.Collections

Best Java code snippets using java.util.Collections.emptyNavigableMap (Showing top 20 results out of 315)

How to use
emptyNavigableMap
method
in
java.util.Collections