返回包装后不可修改的有序Map.

@see java.util.Collections#unmodifiableSortedMap(SortedMap)
972071
public static <K, V> SortedMap<K, V> unmodifiableSortedMap(final SortedMap<K, ? extends V> m) {
		return Collections.unmodifiableSortedMap(m);
	}
573060
public static <K, V> MutableList<V> toSortedList(
            Map<K, V> map,
            Comparator<? super V> comparator)
    {
        return Iterate.toSortedList(map.values(), comparator);
    }
615899
public <K, V> Map<K, V> unmodifiable(Map<K, V> input)
    {
        if (input == null) {
            return null;
        }
        return Collections.unmodifiableMap(input);
    }
21754
private SortedMap<Integer, List<AutocompleteResultsModel>> getCleanedAndSortedMapResults(
            ConcurrentMap<String, List<Tuple<SearchResult, String>>> resultsMap,
            int maxTextLength) {
        SortedMap<Integer, List<AutocompleteResultsModel>> prioritizedResultsMap =
                createAutocompletePriorityMap();

        // Put the results into the map of <priority,list>
        for (Map.Entry<String, List<Tuple<SearchResult, String>>> entry : resultsMap.entrySet()) {
            for (Tuple<SearchResult, String> tupleSearchResult : entry.getValue()) {
                SearchResult searchResult = tupleSearchResult.getFirst();
                List<String> resultTypes = searchResult.getType();
                // If the search result doesn't have a type defined, use the undefined result type.
                if (resultTypes.size() == 0) {
                    resultTypes = UNDEFINED_SEARCH_RESULT_TYPE;
                }
                for (String category : resultTypes) {
                    // Exclude the result if it is a result type that's in the ignore list.
                    if (!autocompleteIgnoreResultTypes.contains(category)) {
                        int priority = calculatePriorityFromCategory(category);
                        AutocompleteResultsModel result =
                                new AutocompleteResultsModel(
                                        cleanAndTrimString(searchResult.getTitle(), maxTextLength),
                                        cleanAndTrimString(
                                                searchResult.getSummary(), maxTextLength),
                                        tupleSearchResult.getSecond(),
                                        category);
                        prioritizedResultsMap.get(priority).add(result);
                    }
                }
            }
        }
        return prioritizedResultsMap;
    }
707844
public static <K, V> V first( NavigableMap<K, V> map ) {
        return map.firstEntry().getValue();
    }
740398
@SuppressWarnings("unchecked")
    public Map<String, Class<?>> getAllEntries() {
        return (Map<String, Class<?>>) MapUtils.unmodifiableMap(entries);
    }
210168
public static <K, V> MutableMap<K, V> rejectMapOnEntry(
            Map<K, V> map,
            Predicate2<? super K, ? super V> predicate)
    {
        return MapIterate.rejectMapOnEntry(map, predicate, UnifiedMap.<K, V>newMap());
    }
344012
public static <K, V> Map<K, V> unmodifiableCopy(
        Map<? extends K, ? extends V> map)
    {
        return Collections.<K, V>unmodifiableMap(
            new LinkedHashMap<K, V>(map));
    }
1308096
public static <K, V> SortedSetMultimap<K, V> createSortedSetMultiValueMap(Comparator<V> comparator) {
		return (SortedSetMultimap<K, V>) MultimapBuilder.hashKeys().treeSetValues(comparator);
	}
730972
@Inline(value="$2.$3copyOfSorted($1)", imported=ImmutableSortedMap.class)
	public static <K, V> SortedMap<K, V> immutableCopy(SortedMap<K, ? extends V> map) {
		return ImmutableSortedMap.copyOfSorted(map);
	}
1129014
public static <K,V> Map<K,V> asImmutable(Map<? extends K, ? extends V> self) {
        return Collections.unmodifiableMap(self);
    }
751992
public static <K extends Comparable<?>, V> ListMultimap<K, V> sortedArrayListMultimap()
    {
        Map<K, Collection<V>> map = Maps.newTreeMap();
        return Multimaps.newListMultimap(map, new Supplier<List<V>>() {
            @Override
            public List<V> get()
            {
                return Lists.newArrayList();
            }
        });
    }
107018
public static <K,V> SortedMap<K,V> asImmutable(SortedMap<K, ? extends V> self) {
        return Collections.unmodifiableSortedMap(self);
    }
285470
@Deprecated
  public static <K, V> List<Entry<K, V>> sortedCopyOfEntries(final Map<K, V> map,
      final Ordering<Map.Entry<K, V>> ordering) {
    return ordering.sortedCopy(map.entrySet());
  }
1108040
public static <K, V> Map<K, V> toSortedMap(Map<K, V> map, Comparator<? super K> comparator) {
        Map<K, V> sortedMap;
        if (comparator == null)
            sortedMap = new LinkedHashMap<>();
        else
            sortedMap = new TreeMap<>(comparator);
        sortedMap.putAll(map);
        return sortedMap;
    }
774134
@Override
    public Set<Map.Entry<String, Object>> entrySet() {
        return Collections.unmodifiableSet(new AbstractSet<Map.Entry<String, Object>>() {
            @Override
            public Iterator<Map.Entry<String, Object>> iterator() {
                return entryIterator();
            }

            @Override
            public int size() {
                return BeanMap.this.types.size();
            }
        });
    }
785941
private static <K, V> ImmutableMap<K, V> filterMapToKeysPreservingOrder(
      final ImmutableMap<? extends K, ? extends V> map, Iterable<? extends K> keys) {
    final ImmutableMap.Builder<K, V> ret = ImmutableMap.builder();
    for (final K key : keys) {
      final V value = map.get(key);
      checkArgument(value != null, "Key " + key + " not in map");
      ret.put(key, value);
    }
    return ret.build();
  }