Returns an array of the keys contained in the underlying container. it does not enumerate the
container and all of its children.

@return The keys in the underlying map as an array of Strings.
320126
public String[] keys () {
        String[] keys = new String[count];
        for (int i = 0; i < count; ++i) {
            keys[i] = container[i].key;
        }
        return keys;
    }
1038609
public function get_key_list() {
        $keys = array();
        foreach ($this->collection as $node) {
            $keys[] = $node->key;
        }
        return $keys;
    }
1356752
public Iterable<RowKey> getKeys() {
		if ( currentState.isEmpty() ) {
			if ( cleared ) {
				// if the association has been cleared and the currentState is empty, we consider that there are no rows.
				return Collections.emptyList();
			}
			else {
				// otherwise, the snapshot rows are the current ones
				return snapshot.getRowKeys();
			}
		}
		else {
			// It may be a bit too large in case of removals, but that's fine for now
			Set<RowKey> keys = CollectionHelper.newLinkedHashSet( cleared ? currentState.size() : snapshot.size() + currentState.size() );

			if ( !cleared ) {
				// we add the snapshot RowKeys only if the association has not been cleared
				for ( RowKey rowKey : snapshot.getRowKeys() ) {
					keys.add( rowKey );
				}
			}

			for ( Map.Entry<RowKey,AssociationOperation> op : currentState.entrySet() ) {
				switch ( op.getValue().getType() ) {
					case PUT:
						keys.add( op.getKey() );
						break;
					case REMOVE:
						keys.remove( op.getKey() );
						break;
				}
			}

			return keys;
		}
	}
1168961
public String[] getKeyStoreAliases() {
        Set<String> set = keyStoreMap.keySet();
        return set.toArray(new String[set.size()]);
    }
354875
public Iterable<FallbackKey> fallbackKeys() {
		return (fallbackKeys == EMPTY) ? Collections.emptyList() : Arrays.asList(fallbackKeys);
	}
500780
def keys(self):
        
        k = list(dict.keys(self))
        k.sort()
        return k
232078
public function keys()
    {
        $locales = array_map(function (LocaleCollection $locales) {
            $keys = $locales->keys()->toArray();
            return array_combine($keys, $keys);
        }, $this->locales);

        $all = [];

        foreach ($locales as $keys) {
            $all = array_merge($all, $keys);
        }

        return $all;
    }
443824
public function keys()
    {
        $current = current($this->items);

        if (is_scalar($current)) {
            $array = $this->items;
        } elseif (is_array($current)) {
            $array = $current;
        } else {
            $array = $current->toArray();
        }

        return array_keys($array);
    }
397438
function getKeys(compositeKey) {
  if (typeof compositeKey === 'string') {
    // else assume string and split around dots
    let keyList = keyMap[compositeKey];
    if (!keyList) {
      keyList = compositeKey.split('.');
      keyMap[compositeKey] = keyList;
    }
    return keyList;
  }
  // Wrap in array if needed
  return Array.isArray(compositeKey) ? compositeKey : [compositeKey];
}
1158326
public Iterator<K> keys()
  {
    KeyIterator<K,V> iter = new KeyIterator<K,V>(this);

    iter.init(this);

    return iter;
  }
1002777
public List<T> getSortedKeys() {
    List<T> l = Lists.newArrayList(counts.keySet());
    Collections.sort(l, Ordering.natural().reverse().onResultOf(Functions.forMap(counts.getBaseMap())));
    return l;
  }
1297238
public function keySet()
    {
        $result = [];
        $keys = $this->keys();
        foreach ($keys as $key) {
            $result[] = $key;
        }

        return $result;
    }
600641
public function getArrayKeys()
    {
        $returnValue = [];

        foreach (array_keys($this->getArrayCopy()) as $key) {
            if ($key != '_type') {
                $returnValue[] = $key;
            }
        }

        return $returnValue;
    }
1132586
public static Iterator<Object> getKeys(Object[] array)
    {
        if (array == null)
        {
            return null;
        }
        ArrayList<Object> keyList = new ArrayList<Object>();
        int i = array.length - 2;
        while (i >= 0)
        {
            keyList.add(array[i]);
            i = i - 2;
        }
        return keyList.iterator();
    }
717372
private function _getKeyIdMap(): array
    {
        // lazily build mapping
        if (!isset($this->_keyIdMap)) {
            $this->_keyIdMap = array();
            foreach ($this->_certs as $cert) {
                $id = self::_getCertKeyId($cert);
                if (!isset($this->_keyIdMap[$id])) {
                    $this->_keyIdMap[$id] = array();
                }
                array_push($this->_keyIdMap[$id], $cert);
            }
        }
        return $this->_keyIdMap;
    }
544270
public synchronized Collection<String> getNames() {
        if (map == null) {
            return Collections.emptySet();
        }
        return Collections.unmodifiableSet(new HashMap<String,String>(map).keySet());
    }
659466
public java.util.List<KeyListEntry> getKeys() {
        if (keys == null) {
            keys = new com.amazonaws.internal.SdkInternalList<KeyListEntry>();
        }
        return keys;
    }