Currency converter

Este artículo trata sobre código de software que convierte moneda. Para que las plantillas se usen para la conversión de monedas en Wikipedia, vea Categoría: Plantillas de conversión de divisas.

Un convertidor de moneda es un código de software diseñado para convertir una moneda en otra para comprobar su valor correspondiente. El código es generalmente una parte de un sitio web o forma una aplicación móvil y se basa en los tipos de cambio actuales del mercado o del banco.

Con el fin de convertir una moneda en otra, un usuario introduce una cantidad de dinero (por ejemplo, '1000') y elige la moneda que desea comprobar el valor monetario de (por ejemplo, 'dólar estadounidense'). Después de eso, el usuario selecciona uno, oa veces varias otras monedas, él / ella quisiera ver el resultado adentro. El software de la aplicación entonces calcula y exhibe la cantidad de dinero correspondiente.

Los convertidores de moneda tienen como objetivo mantener información en tiempo real sobre los tipos de cambio actuales del mercado o del banco, de manera que el resultado calculado cambia siempre que el valor de cualquiera de las monedas componentes lo haga. Lo hacen mediante la conexión a una base de datos de los tipos de cambio actuales.

Los convertidores de moneda normalmente muestran un valor que no está sesgado hacia la compra o venta. Esto es útil cuando:

Estimación del valor de los bienes o servicios

Contabilidad básica y facturación

Preparación de planes e informes financieros

Los convertidores de moneda se utilizan a menudo como medio de comprobar el valor relativo de una moneda antes de intercambiarla en otra moneda. Esto es útil para el viajero porque el viajero puede comprobar el valor de la moneda de un condado extranjero antes de intercambiar dinero. Estos programas enumeran el valor de la moneda de un país extranjero en relación con la moneda del viajero.

El software de conversión de divisas calcula las tasas como números de punto decimal con típicamente 4 decimales después de la coma. Algunos pueden calcular las tasas de conversión con más decimales internamente, pero solo se muestran 4. Esto está relacionado con la precisión, la internalización del software (i18n) y cómo funciona el mercado Forex (divisas), donde la mayoría de las conversiones tienen 4 decimales, aunque algunos pares de divisas también tienen 5. La mayoría de los convertidores de divisas utilizan hasta 4.

Algunos software de conversión de divisas convierte moneda junto con información sobre las monedas. Esta información puede ser muy útil para los viajeros y aquellos que buscan ganar dinero mediante el comercio de divisas.

El valor de la moneda fluctúa constantemente y es afectado por una variedad de factores diferentes, incluyendo:

El valor de las importaciones y exportaciones de la nación

La relativa estabilidad política del país

Guerra en la región

Desastres naturales

Las deudas públicas del país con otros países

Las políticas reguladoras del banco central del país

La fluctuación de las tasas de inflación del condado.

Estos programas de conversión de monedas tratan de armar al usuario con conocimientos que pueden llevar al usuario a una conjetura educada sobre las fluctuaciones futuras de la moneda de un país. Un comerciante buscaría comprar la moneda a una tarifa baja y venderla a una tarifa alta, mientras que un viajero podría esperar para intercambiar el dinero en el país en un mercado favorable.

Ejemplo 1:

private static String currencySymbol(@Nonnull final String currencyCode)
{
 try
 {
  final Currency currency = Currency.getInstance(currencyCode);
  return currency.getSymbol();
 }
 catch (final IllegalArgumentException x)
 {
  return currencyCode;
 }
}

Ejemplo 2:

public void testUnmarshal() {
 
    assertEquals(Currency.getInstance("USD"), BINDING.unmarshal("USD"));
    assertEquals(Currency.getInstance("GBP"), BINDING.unmarshal("GBP"));
    assertEquals(Currency.getInstance("AUD"), BINDING.unmarshal("AUD"));
}

Ejemplo 3:
public void test() {

  Locale locale = Locale.getDefault();
  Currency currency = Currency.getInstance(locale);
  TimeZone tz = TimeZone.getDefault();

  ESomeType e = new ESomeType();
  e.setLocale(locale);
  e.setTimeZone(tz);
  e.setCurrency(currency);

  Ebean.save(e);

  ESomeType e2 = Ebean.find(ESomeType.class).setAutoTune(false).setId(e.getId()).findUnique();

  Assert.assertNotNull(e2.getCurrency());
  Assert.assertNotNull(e2.getLocale());
  Assert.assertNotNull(e2.getTimeZone());

  List<ESomeType> list = Ebean.find(ESomeType.class)
      .setAutoTune(false).where()
      .eq("locale", locale)
      .eq("timeZone", tz.getID())
      .eq("currency", currency)
      .findList();

  assertTrue(!list.isEmpty());
}
 
Ejemplo 4: 
public Fare getCost(GraphPath path) {

    List<Ride> rides = createRides(path);
    // If there are no rides, there's no fare.
    if (rides.size() == 0) {
        return null;
    }
    // pick up a random currency from fareAttributes, 
    // we assume that all tickets use the same currency
    Currency currency = null; 
    WrappedCurrency wrappedCurrency = null;
    if (fareAttributes.size() > 0) {
        currency = Currency.getInstance(
            fareAttributes.values().iterator().next().getCurrencyType());
        wrappedCurrency = new WrappedCurrency(currency);
    }
    float lowestCost = getLowestCost(rides);
    if (lowestCost != Float.POSITIVE_INFINITY) {
        int fractionDigits = 2;
        if (currency != null)
            fractionDigits = currency.getDefaultFractionDigits();
        int cents = (int) Math.round(lowestCost * Math.pow(10, fractionDigits));
        Fare fare = new Fare();
        fare.addFare(FareType.regular, wrappedCurrency, cents);
        return fare;
    } else {
        return null;
    }
}

Ejemplo 5: 
rivate static Map<String, String> getAllCurrencies() {
    Map<String, String> currencies = new TreeMap<String, String>();
    for (Locale locale : Locale.getAvailableLocales()) {
        if (StringUtils.isNotBlank(locale.getCountry())) {
            Currency currency = Currency.getInstance(locale);
            currencies.put(currency.getCurrencyCode(),
                    currency.getSymbol(locale));
        }
    }
    return currencies;
}

Ejemplo 6:
public static Object asType(Class<?> type, String string) {
    if (isBoolean(type)) {
        return Boolean.parseBoolean(string);
    } else if (isInteger(type)) {
        return Integer.parseInt(string);
    } else if (isLong(type)) {
        return Long.parseLong(string);
    } else if (isDouble(type)) {
        return Double.parseDouble(string);
    } else if (isFloat(type)) {
        return Float.parseFloat(string);
    } else if (isByte(type)) {
        return Byte.parseByte(string);
    } else if (isShort(type)) {
        return Short.parseShort(string);
    } else if (isBigInteger(type)) {
        return new BigInteger(string);
    } else if (isBigDecimal(type)) {
        return new BigDecimal(string);
    } else if (isCalendar(type)) {
        return DatatypeConverter.parseDateTime(string);
    } else if (isDate(type)) {
        if (isIsoLatin1Number(string)) {
            return new Date(Long.parseLong(string));
        } else {
            return DatatypeConverter.parseDateTime(string)
                    .getTime();
        }
    } else if (isCurrency(type)) {
        return Currency.getInstance(string);
    } else if (type.isEnum()) {
        return Enum.valueOf((Class<? extends Enum>) type, string);
    } else {
        return string;
    }
}

Ejemplo 7: 
public int doStartTag() throws JspException {
  try {
    if (value > -1) {
      NumberFormat formatter = NumberFormat.getCurrencyInstance(locale);
      if (code != null) {
        Currency currency = Currency.getInstance(code);
        formatter.setCurrency(currency);
      }
      this.pageContext.getOut().write(StringUtils.toHtmlValue(formatter.format(value)));
    } else {
      //no data found, output default
      if (defaultValue != null) {
        this.pageContext.getOut().write(defaultValue);
      }
    }
  } catch (Exception e) {
    System.out.println(e.getMessage());
  }
  return SKIP_BODY;
}
 
Ejemplo 8: 
 public static Money deserialize(final String serializedMoney) {
    final int seperatorIndex = serializedMoney.indexOf(SEPERATOR);
    final String currencyCode = serializedMoney.substring(0, seperatorIndex);
    final String valueString = serializedMoney.substring(seperatorIndex + 1);
    final BigDecimal value = new BigDecimal(valueString);
    return new Money(Currency.getInstance(currencyCode), value);
}
Ejemplo 9:
private Currency parseCurrency(final String currencyStr)
{
 if (currencyStr.equals("US$"))
  return Currency.getInstance("USD");
 if (currencyStr.equals("Dirham"))
  return Currency.getInstance("AED");
 return Currency.getInstance(currencyStr);
}
Ejemplo 10:
public OPDSPrice selectBestPrice() {
 if (Prices.isEmpty()) {
  return null;
 } else if (Prices.size() == 1) {
  return Prices.get(0);
 }
 OPDSPrice price;
 final Locale locale = Locale.getDefault();
 if (locale.getCountry().length() == 2) {
  final String bestCode = Currency.getInstance(locale).getCurrencyCode();
  if (bestCode != null) {
   price = getPrice(bestCode);
   if (price != null) {
    return price;
   }
  }
 }
 price = getPrice("USD");
 if (price != null) {
  return price;
 }
 price = getPrice("EUR");
 if (price != null) {
  return price;
 }
 return Prices.get(0);
}




WebGrafía : https://www.programcreek.com/java-api-examples/java.util.Currency