Get the keys in byte form for all of the string keys.

@param keys a collection of keys
@return return a collection of the byte representations of keys
502790
public static Collection<byte[]> getKeyBytes(Collection<String> keys) {
        Collection<byte[]> rv=new ArrayList<byte[]>(keys.size());
        for(String s : keys) {
            rv.add(getKeyBytes(s));
        }
        return rv;
    }
524950
public List<String> writeBulk(final List<String> keys) throws Exception {
        List<String> responses = new ArrayList<>(keys.size());
        for (String key : keys) {
            String response = writeSingle(key);
            responses.add(response);
        }
        return responses;
    }
900352
public final List<String> getKeyList() {
        final List<String> keys = new ArrayList<>();
        final Iterator<String> it = keyIterator();
        while (it.hasNext()) {
            keys.add(it.next());
        }
        return keys;
    }
698822
public static List<String> getStringsWithGroup(String groupName,String...keys){
        try {
        	if(JedisProviderFactory.isCluster(groupName)){
        		return JedisProviderFactory.getMultiKeyJedisClusterCommands(groupName).mget(keys);
        	}else{
        		return JedisProviderFactory.getMultiKeyCommands(groupName).mget(keys);
        	}
		} finally {
			JedisProviderFactory.getJedisProvider(groupName).release();
		}
	}
127471
public final String[] keys()
  {
    String [] keysArr = new String[m_firstFree];

    for (int i = 0; i < m_firstFree; i++)
    {
      keysArr[i] = m_map[i];
    }

    return keysArr;
  }
712515
public Set<String> getKeySet() {
    final HashSet<String> keySet = new HashSet<>();

    keySet.addAll(localKeySet());

    if (this._parent != null) {
      keySet.addAll(this._parent.getKeySet());
    }

    return keySet;
  }
1311109
public <K2 extends K> BlockingListMaker<K2, E> useKeys(Collection<? extends K2> keys) {
        @SuppressWarnings("unchecked")
        BlockingListMaker<K2, E> stricterThis = (BlockingListMaker<K2, E>) this;
        stricterThis.keys = keys;
        return stricterThis;
    }
309722
protected static final <T, K extends Serializable>
    List<K> _keys2Ids(
                    final Collection<Key<T>> keys
                    )
    {
        List<K>  ids = new ArrayList<K>();
        if (keys != null ) {
            for (Key<T>  key : keys) {
                @SuppressWarnings( "unchecked" )
                K  id = (K)key.getId();
                ids.add( id );
            }
        }

        return ids;
    }
1231532
public <T> Map<String, T> get(String... fields) {
		try {
			List<byte[]> datas = null;
			Map<String, T> result = new HashMap<>();
			
			byte[][] encodeFileds = SafeEncoder.encodeMany(fields);
			if (isCluster(groupName)) {
				datas = getBinaryJedisClusterCommands(groupName).hmget(keyBytes, encodeFileds);
			} else {
				datas = getBinaryJedisCommands(groupName).hmget(keyBytes, encodeFileds);
			}
			for (int i = 0; i < fields.length; i++) {
				result.put(fields[i], (T)valueDerialize(datas.get(i)));
			}
			return result;
		} finally {
			getJedisProvider(groupName).release();
		}

	}
297421
public static int[] mapQuoteKeys(String keys) {
        if(keys != null && keys.length() > 1)
            return mapKeys(keys.substring(1));
        else
            return null;
    }
1132038
public Set<DOCUMENT> query(Iterable<KEY> keys) {
      return query(keys, d -> true);
   }
561597
int[] getKeys()
    {
        Set<Integer> keySet = map.keySet();
        int keys[] = new int[keySet.size()];
        int index = 0;
        for (Integer key : keySet)
        {
            keys[index] = key;
            index++;
        }
        return keys;
    }
772325
public byte[] getKeySetToByteArray() 
    {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        DataOutputStream dos = new DataOutputStream(baos);
        
        char[] buffer = new char[getMaxFieldLenth()];
        
        try
        {
            for ( String s : keys )
            {
                Arrays.fill(buffer, (char)0);
                System.arraycopy( s.toCharArray(), 0, buffer, 0, s.length() );
                dos.writeBytes( new String(buffer) );
            }
        }
        catch  (IOException e)
        {
            System.err.println("Could not write Structure key set to byte array: " + e );
            return new byte[0];
        }
        return baos.toByteArray();
        
    }
1286700
protected List<?> keysToIds(final List<Key<T>> keys) {
        final List<Object> ids = new ArrayList<Object>(keys.size() * 2);
        for (final Key<T> key : keys) {
            ids.add(key.getId());
        }
        return ids;
    }
94231
public ValueType get(final KeyType... keys) {

        if (ArrayUtils.isEmpty(keys)) {
            return null;
        }
        int keysLength = keys.length;
        if (keysLength == 1) {
            return get(keys[0]);
        } else {
            StorageComponent<KeyType, ValueType> storageComponent = this;
            int lastKeyIndex = keysLength - 1;
            for (int i = 0; i < lastKeyIndex; i++) {
                KeyType storageComponentKey = keys[i];
                storageComponent = storageComponent.getStorageComponent(storageComponentKey);
            }
            return storageComponent.get(keys[lastKeyIndex]);
        }
    }
445453
public Set<Object> hkeys(Object key) {
		Jedis jedis = getJedis();
		try {
			Set<byte[]> fieldSet = jedis.hkeys(keyToBytes(key));
			Set<Object> result = new HashSet<Object>();
			fieldSetFromBytesSet(fieldSet, result);
			return result;
		}
		finally {close(jedis);}
	}
1189503
public RequestLimitRule matchingKeys(Set<String> keys) {
        return new RequestLimitRule(this.durationSeconds, this.limit, this.precision, this.name, keys);
    }