Return a filtered set of entries.
@see Map.entryset
433101
public Set<Map.Entry<K, V>> entrySet() { 
       HashSet s = new HashSet(mBackingMap.size());
       for (Map.Entry e : mBackingMap.entrySet()) {
           if (mFilter.accept(e))
               s.add(e);
       }
       return s;
    }
402233
@Override
	public Set<Entry<Object, Object>> entrySet() {
		final Set<Entry<Object, Object>> entrySet = new HashSet<Entry<Object, Object>>();
		lock.readLock().lock();
		try {
			final boolean useLocalPrefixes = !mixDefaultAndLocalPrefixes && hasLocalPrefixConfigurations();
			for (final Map.Entry<Object, Object> keyEntry : getKeyMap(false).entrySet()) {
				final Object value = get(keyEntry.getValue(), useLocalPrefixes);
				if (String.class == keyEntry.getKey().getClass()) {
					entrySet.add(new PPEntry(keyEntry.getKey(), value));
				} else {
					entrySet.add(new PPEntry(keyEntry.getKey(), value));
				}
			}
			return entrySet;
		} finally {
			lock.readLock().unlock();
		}
	}
1083645
public static Map mapEntries(Mapper mapper, Map map) {
        return mapEntries(mapper, map, false);
    }
34047
public synchronized Set<java.util.Map.Entry<String, XAttribute>> entrySet() {
		if(backingStore != null) {
			return backingStore.entrySet();
		} else {
			return EMPTY_ENTRYSET;
		}
	}
688820
public static <K, V> Map<K, V> filter(Map<K, V> map, Filter<Entry<K, V>> filter) {
		return MapUtil.filter(map, filter);
	}
505859
public static Map<String, ImageArchiveManifestEntry> mapEntriesById(Iterable<ImageArchiveManifestEntry> entries) {
        Map<String, ImageArchiveManifestEntry> mapped = new LinkedHashMap<>();

        for(ImageArchiveManifestEntry entry : entries) {
            mapped.put(entry.getId(), entry);
        }

        return mapped;
    }
946204
@Override
    public Set<Entry<String, Object>> entrySet() {
        return new AbstractSet<Entry<String, Object>>() {
            @Override
            public Iterator<Entry<String, Object>> iterator() {
                return entryIterator();
            }

            @Override
            public int size() {
                return BeanMap.this.readMethods.size();
            }
        };
    }
1234000
private static <K, V> SortedMap<K, V> filterFiltered(
      FilteredEntrySortedMap<K, V> map, Predicate<? super Entry<K, V>> entryPredicate) {
    Predicate<Entry<K, V>> predicate = Predicates.<Entry<K, V>>and(map.predicate, entryPredicate);
    return new FilteredEntrySortedMap<K, V>(map.sortedMap(), predicate);
  }
905786
@Override
  public Set<Map.Entry<K,V>> entrySet() {
    return new AbstractSet<Map.Entry<K,V>>() {
      @Override
      public Iterator<Map.Entry<K,V>> iterator() {
        Filter<Map.Entry<K,V>> filter1 = new Filter<Map.Entry<K,V>>() {
          private static final long serialVersionUID = 1L;

          // only accepts stuff not overwritten by deltaMap
          public boolean accept(Map.Entry<K,V> e) {
            K key = e.getKey();
            return ! deltaMap.containsKey(key);
          }
        };

        Iterator<Map.Entry<K, V>> iter1 = new FilteredIterator<Map.Entry<K, V>>(originalMap.entrySet().iterator(), filter1);

        Filter<Map.Entry<K,V>> filter2 = new Filter<Map.Entry<K,V>>() {
          private static final long serialVersionUID = 1L;
          // only accepts stuff not overwritten by deltaMap
          public boolean accept(Map.Entry<K,V> e) {
            Object value = e.getValue();
            if (value == removedValue) {
              return false;
            }
            return true;
          }
        };

        class NullingIterator<K, V> implements Iterator<Map.Entry<K,V>> {
          private Iterator<Map.Entry<K, V>> i;

          public NullingIterator(Iterator<Map.Entry<K, V>> i) {
            this.i = i;
          }

          public boolean hasNext() {
            return i.hasNext();
          }

          public Map.Entry<K, V> next() {
            Map.Entry<K,V> e = i.next();
            Object o = e.getValue();
            if (o == nullValue) {
              return new SimpleEntry<K,V>(e.getKey(), null);
            }
            return e;
          }

          public void remove() {
            throw new UnsupportedOperationException();
          }
        }

        Iterator<Entry<K, V>> iter2 = new FilteredIterator<Entry<K,V>>(new NullingIterator<K, V>(deltaMap.entrySet().iterator()), filter2);

        return new ConcatenationIterator<Entry<K,V>>(iter1, iter2);
      }

      @Override
      public int size() {
        int size = 0;
        for (Entry<K, V> kvEntry : this) {
          ErasureUtils.noop(kvEntry);
          size++;
        }
        return size;
      }
    };
  }
1018297
@SafeVarargs
    public static <K, V> Map<K, V> map(final Entry<? extends K, ? extends V>... entries) {
        final Map<K, V> map = new LinkedHashMap<K, V>(entries.length);
        for (final Entry<? extends K, ? extends V> entry : entries) {
            map.put(entry.getKey(), entry.getValue());
        }
        return map;
    }
452768
public Iterable<Map.Entry<Integer, Record>> entries() {
        return () -> new Iterator<Map.Entry<Integer, Record>>() {
            private final Iterator<Map.Entry<Integer, Record>> it = data.records.entrySet().iterator();

            /** {@inheritDoc} */
            @Override
            public boolean hasNext() {
                return it.hasNext();
            }

            /** {@inheritDoc} */
            @Override
            public Map.Entry<Integer, Record> next() {
                return it.next();
            }

            /** {@inheritDoc} */
            @Override
            public void remove() {
                throw new UnsupportedOperationException("This is a read-only iterator, remove operation is not supported.");
            }
        };
    }
783948
@Override public ImmutableSet<Entry<K, V>> entries() {
    ImmutableSet<Entry<K, V>> result = entries;
    return (result == null)
        ? (entries = new EntrySet<K, V>(this))
        : result;
  }
733613
protected Set<E> set() {
    return elements.entrySet()
        .stream()
        .filter(entry -> !entry.getValue().isTombstone())
        .map(entry -> decode(entry.getKey()))
        .collect(Collectors.toSet());
  }
253580
public Set<String> entries() {
        Set<String> es = this.entries;
        if (es == null) {
            // lazily scan the entries
            this.entries = scan();
        }
        return this.entries;
    }
1296805
public Set entrySet() {
        if(_entrySet == null) {
            Map piMap = InternalUtils.getPageInputMap(_request);
            ArrayList list = new ArrayList();
            if(piMap != null) {
                Iterator iterator = piMap.keySet().iterator();
                while(iterator.hasNext()) {
                    Object name = iterator.next();
                    Object value = piMap.get(name);
                    list.add(new Entry(name, value));
                }
            }

            _entrySet = new EntrySet((Entry[])list.toArray(new Entry[]{}));
        }

        return _entrySet;
    }
791982
@Override
    public Set<java.util.Map.Entry<K, V>> entrySet() {
        return Collections.emptySet();
    }
515964
private Map<String, Object> filterUnexpectedKeys(Map<String, Object> inputProps) {
        Map<String, Object> outputProps = new HashMap<String, Object>();

        Set<Entry<String, Object>> entries = inputProps.entrySet();
        for (Map.Entry<String, Object> entry : entries) {
            String key = entry.getKey();
            if (EXPECTED_KEYS.contains(key)) {
                outputProps.put(key, entry.getValue());
            }
        }
        return outputProps;
    }