Gets the double.

@param valueAsStr
the value as str
@return the double
489870
private double getDouble(String valueAsStr)
    {
        return StringUtils.isNumeric(valueAsStr) ? Double.parseDouble(valueAsStr) : Double
                .parseDouble(((Integer) valueAsStr.hashCode()).toString());
    }
89038
public static double getDouble(String name, double defaultVal){
        if(getConfiguration().containsKey(name)){
            return getConfiguration().getDouble(name);
        } else {
            return defaultVal;
        }
    }
1341971
public static Double parse(final String s) {
        Double parsed = null;
        try {
            if (s != null) {
                parsed = Double.parseDouble(s);
            }
        } catch (final NumberFormatException e) {
        }
        return parsed;
    }
167770
@Override
    public double getDoubleValue( final String       key,
                                  final double       defaultValue )
    {
        return formatDoubleValue( key, getFormattedPropValue( key ), defaultValue );
    }
424357
@Override
    public double value(Attribute attribute) {
        int index = this.instanceHeader.indexOf(attribute);
        return value(index);
    }
197960
public double getDouble(int index)
  {
    Object value = _values[index - 1];

    if (value instanceof Double) {
      return (Double) value;
    }
    else if (value instanceof Float) {
      return (Float) value;
    }
    else if (value instanceof Number) {
      return (Double) ((Number) value);
    }
    else {
      return Double.valueOf(value.toString());
    }
  }
92458
public Double getDouble(String name) {
        Object o = get(name);
        if (o instanceof Number) {
            return ((Number)o).doubleValue();
        }

        if (o != null) {
            try {
                String string = o.toString();
                if (string != null) {
                    return Double.parseDouble(string);
                }
            }
            catch (NumberFormatException e) {}
        }
        return null;
    }
68128
private Object parseAttributeValue(XAttribute xAttribute) {
		String attributeString = xAttribute.toString();

		// TODO better solution?

		// All numeric values as double
		try {
			double a = Double.parseDouble(attributeString);
			return a;
		} catch (NumberFormatException e) {
			// Ignore
		}
		// Boolean
		if (attributeString.trim().toLowerCase().equals("true"))
			return true;
		if (attributeString.trim().toLowerCase().equals("false"))
			return false;
		// String
		return attributeString;
	}
515808
public Float getFloat(String attr) {
		Number n = (Number)attrs.get(attr);
		return n != null ? n.floatValue() : null;
	}
1009808
public double getDouble(String property) {
    return getProperty(property, value -> {
      try {
        return Double.valueOf(value);
      } catch (NumberFormatException e) {
        throw new ConfigurationException("malformed property value: " + property + " must be a double");
      }
    });
  }
935369
public static ComparableSimpleDateFormat compile(final String valueStr)
    {
        final ComparableSimpleDateFormat cp = new ComparableSimpleDateFormat();
        cp.delegate = new SimpleDateFormat(valueStr);
        cp.pattern = valueStr;
        return cp;
    }
712631
public static double toDouble(@NotNull String str) {
		// 统一行为，不要有时候抛NPE，有时候抛NumberFormatException
		if (str == null) {
			throw new NumberFormatException("null");
		}
		return Double.parseDouble(str);
	}
704789
public Double getDouble (int index) {
        String string = getString (index);
        return (string != null) ? Double.parseDouble (string) : null;
    }
706569
@Override
	public double getDouble(String fldName) throws RemoteException {
		try {
			fldName = fldName.toLowerCase(); // to ensure case-insensitivity
			return (Double) s.getVal(fldName).castTo(DOUBLE).asJavaVal();
		} catch (RuntimeException e) {
			rconn.rollback();
			throw e;
		}
	}
88485
public double doubleValue(String name) {
        String s = childValue(name);
        if (s != null) {
            return Double.parseDouble(s);
        }
        throw new IllegalArgumentException(this + ": content: " + name);
    }
245726
public static double getDouble(
    Object      value)
  {
    if (value == null)
    {
        return 0;
    }

    return Double.valueOf(value.toString()).doubleValue();

  }
1129807
private double parseIntoDouble(String value) {
        double returnVal = 0.0;
        if (value.charAt(0) == '.') value = "0" + value;
        int bracketIndex = value.indexOf('(');
        if (bracketIndex != -1) {
            value = value.substring(0, bracketIndex);
        }
        try {
            returnVal = Double.parseDouble(value);
        } catch (Exception exception) {
            logger.error("Could not parse double string: ", value);
        }
        return returnVal;
    }