Gets the prefixed key and parse it to an float[]<br>
Each comma-separated list can be used.

@param key
the key
@return float[] or null if the key couldn't get found.
487308
public float[] getFloatArray(final String key) {
		final String[] value = getArray(key);
		if (value != null) {
			final float[] result = new float[value.length];
			for (int i = 0; i < value.length; i++) {
				result[i] = Float.parseFloat(value[i]);
			}
			return result;
		}
		return null;
	}
470733
public JSONArray getArray(String key) {
        Object tmp = objectMap.get(key);
        return tmp == null ? null : tmp instanceof JSONArray ? (JSONArray) tmp
                : null;
    }
17258
public Optional<List<String>> getList(String key) {
    return this.get(key).map(v -> ImmutableList.copyOf(Splitter.on(',').split(v)));
  }
1196894
@Override
  public List<V> get(Object key)
  {
    if (key == null) {
      return null;
    }

    K[] keys = _keys;
    int size = _size;
    
    for (int i = size - 1; i >= 0; i--) {
      if (key.equals(keys[i])) {
        return _values[i];
      }
    }
    return null;
  }
840457
@Override
    public MutableArray getArray(@NonNull String key) {
        return ((MutableDictionary) internalDict).getArray(key);
    }
530118
public Float getAsFloat(String key) {
        Object value = mValues.get(key);
        try {
            return value != null ? ((Number) value).floatValue() : null;
        } catch (ClassCastException e) {
            if (value instanceof CharSequence) {
                try {
                    return Float.valueOf(value.toString());
                } catch (NumberFormatException e2) {
                    logger.severe( "Cannot parse Float value for " + value + " at key " + key);
                    return null;
                }
            } else {
                logger.log(Level.SEVERE, "Cannot cast value for " + key + " to a Float: " + value, e);
                return null;
            }
        }
    }
511530
public float getFloat( String key )
        throws MissingResourceException
    {
        ResourceBundle bundle = getBundle();
        String value = bundle.getString( key );
        try
        {
            return Float.parseFloat( value );
        }
        catch( NumberFormatException nfe )
        {
            throw new MissingResourceException( "Expecting a float value but got " + value,
                                                "java.lang.String",
                                                key
            );
        }
    }
179433
public LinkedList<Map.Entry<String, V>> commonPrefixSearchWithValue(String key)
    {
        char[] chars = key.toCharArray();
        return commonPrefixSearchWithValue(chars, 0);
    }
565129
public ArrayList<String> get(String key) {
    Iterator<Pair<String, ArrayList<String>>> it = store.iterator();
    while (it.hasNext()) {
      Pair<String, ArrayList<String>> pair = it.next();
      if (key.equals(pair.first)) {
        return pair.second;
      }
    }
    return null;
  }
1207943
private static String[] parseRawParamKey(String rawKey) {
        List<String> list = new ArrayList<>();
        int len = rawKey.length();
        boolean inSquare = false;
        S.Buffer token = S.buffer();
        for (int i = 0; i < len; ++i) {
            char c = rawKey.charAt(i);
            switch (c) {
                case '.':
                    if (inSquare) {
                        token.append(c);
                    } else {
                        addTokenToList(list, token);
                    }
                    continue;
                case ']':
                    inSquare = false;
                    addTokenToList(list, token);
                    continue;
                case '[':
                    inSquare = true;
                    addTokenToList(list, token);
                    continue;
                default:
                    token.append(c);

            }
        }
        addTokenToList(list, token);
        return list.toArray(new String[list.size()]);
    }
854359
public float getFloat(String key) {
		addToDefaults(key, null);
		String value = getRequired(key);
		return Float.valueOf(value);
	}
1357795
@Override
    public float getFloat(@NonNull String key) {
        if (key == null) { throw new IllegalArgumentException("key cannot be null."); }

        synchronized (lock) {
            return CBLConverter.asFloat(getMValue(internalDict, key), internalDict);
        }
    }
784131
public static float getFloat(final String key, final float def) {
		try {
			return systemRoot.getFloat(fixKey(key), def);
		} catch (final Exception e) {
			// just eat the exception to avoid any system
			// crash on system issues
			return def;
		}
	}
1334743
public String get(String key) {
        Preconditions.checkNotNull(key, "key is null");
        return values.get(key);
    }
1350162
public float[] getFloatVec(String key)
    {
        float[] vec = NativeLight.getFloatVec(getNative(), key);
        if (vec == null)
            throw new IllegalArgumentException("key " + key + " not found in light");
        return vec;
    }
1334377
@Override
  public Enumeration<String> getHeaders(String key)
  {
    ArrayList<String> values = new ArrayList<String>();
    
    int i = -1;
    while ((i = matchNextHeader(i + 1, key)) >= 0) {
      values.add(_headerValues[i].toString());
    }

    return Collections.enumeration(values);
  }
1073021
public String[] getStringArray(String key) {
    String effectiveKey = definitions.validKey(key);
    Optional<PropertyDefinition> def = getDefinition(effectiveKey);
    if ((def.isPresent()) && (def.get().multiValues())) {
      String value = getString(key);
      if (value == null) {
        return ArrayUtils.EMPTY_STRING_ARRAY;
      }

      List<String> values = new ArrayList<>();
      for (String v : Splitter.on(",").trimResults().split(value)) {
        values.add(v.replace("%2C", ","));
      }
      return values.toArray(new String[values.size()]);
    }

    return getStringArrayBySeparator(key, ",");
  }