|
Java example source code file (Currency.java)
The Currency.java Java example source code/* * Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. Oracle designates this * particular file as subject to the "Classpath" exception as provided * by Oracle in the LICENSE file that accompanied this code. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */ package java.util; import java.io.BufferedInputStream; import java.io.DataInputStream; import java.io.File; import java.io.FileInputStream; import java.io.FileReader; import java.io.IOException; import java.io.Serializable; import java.security.AccessController; import java.security.PrivilegedAction; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentMap; import java.util.regex.Pattern; import java.util.regex.Matcher; import java.util.spi.CurrencyNameProvider; import sun.util.locale.provider.LocaleServiceProviderPool; import sun.util.logging.PlatformLogger; /** * Represents a currency. Currencies are identified by their ISO 4217 currency * codes. Visit the <a href="http://www.iso.org/iso/home/standards/currency_codes.htm"> * ISO web site</a> for more information. * <p> * The class is designed so that there's never more than one * <code>Currency instance for any given currency. Therefore, there's * no public constructor. You obtain a <code>Currency instance using * the <code>getInstance methods. * <p> * Users can supersede the Java runtime currency data by means of the system * property {@code java.util.currency.data}. If this system property is * defined then its value is the location of a properties file, the contents of * which are key/value pairs of the ISO 3166 country codes and the ISO 4217 * currency data respectively. The value part consists of three ISO 4217 values * of a currency, i.e., an alphabetic code, a numeric code, and a minor unit. * Those three ISO 4217 values are separated by commas. * The lines which start with '#'s are considered comment lines. An optional UTC * timestamp may be specified per currency entry if users need to specify a * cutover date indicating when the new data comes into effect. The timestamp is * appended to the end of the currency properties and uses a comma as a separator. * If a UTC datestamp is present and valid, the JRE will only use the new currency * properties if the current UTC date is later than the date specified at class * loading time. The format of the timestamp must be of ISO 8601 format : * {@code 'yyyy-MM-dd'T'HH:mm:ss'}. For example, * <p> * <code> * #Sample currency properties<br> * JP=JPZ,999,0 * </code> * <p> * will supersede the currency data for Japan. * * <p> * <code> * #Sample currency properties with cutover date<br> * JP=JPZ,999,0,2014-01-01T00:00:00 * </code> * <p> * will supersede the currency data for Japan if {@code Currency} class is loaded after * 1st January 2014 00:00:00 GMT. * <p> * Where syntactically malformed entries are encountered, the entry is ignored * and the remainder of entries in file are processed. For instances where duplicate * country code entries exist, the behavior of the Currency information for that * {@code Currency} is undefined and the remainder of entries in file are processed. * * @since 1.4 */ public final class Currency implements Serializable { private static final long serialVersionUID = -158308464356906721L; /** * ISO 4217 currency code for this currency. * * @serial */ private final String currencyCode; /** * Default fraction digits for this currency. * Set from currency data tables. */ transient private final int defaultFractionDigits; /** * ISO 4217 numeric code for this currency. * Set from currency data tables. */ transient private final int numericCode; // class data: instance map private static ConcurrentMap<String, Currency> instances = new ConcurrentHashMap<>(7); private static HashSet<Currency> available; // Class data: currency data obtained from currency.data file. // Purpose: // - determine valid country codes // - determine valid currency codes // - map country codes to currency codes // - obtain default fraction digits for currency codes // // sc = special case; dfd = default fraction digits // Simple countries are those where the country code is a prefix of the // currency code, and there are no known plans to change the currency. // // table formats: // - mainTable: // - maps country code to 32-bit int // - 26*26 entries, corresponding to [A-Z]*[A-Z] // - \u007F -> not valid country // - bits 18-31: unused // - bits 8-17: numeric code (0 to 1023) // - bit 7: 1 - special case, bits 0-4 indicate which one // 0 - simple country, bits 0-4 indicate final char of currency code // - bits 5-6: fraction digits for simple countries, 0 for special cases // - bits 0-4: final char for currency code for simple country, or ID of special case // - special case IDs: // - 0: country has no currency // - other: index into sc* arrays + 1 // - scCutOverTimes: cut-over time in millis as returned by // System.currentTimeMillis for special case countries that are changing // currencies; Long.MAX_VALUE for countries that are not changing currencies // - scOldCurrencies: old currencies for special case countries // - scNewCurrencies: new currencies for special case countries that are // changing currencies; null for others // - scOldCurrenciesDFD: default fraction digits for old currencies // - scNewCurrenciesDFD: default fraction digits for new currencies, 0 for // countries that are not changing currencies // - otherCurrencies: concatenation of all currency codes that are not the // main currency of a simple country, separated by "-" // - otherCurrenciesDFD: decimal format digits for currencies in otherCurrencies, same order static int formatVersion; static int dataVersion; static int[] mainTable; static long[] scCutOverTimes; static String[] scOldCurrencies; static String[] scNewCurrencies; static int[] scOldCurrenciesDFD; static int[] scNewCurrenciesDFD; static int[] scOldCurrenciesNumericCode; static int[] scNewCurrenciesNumericCode; static String otherCurrencies; static int[] otherCurrenciesDFD; static int[] otherCurrenciesNumericCode; // handy constants - must match definitions in GenerateCurrencyData // magic number private static final int MAGIC_NUMBER = 0x43757244; // number of characters from A to Z private static final int A_TO_Z = ('Z' - 'A') + 1; // entry for invalid country codes private static final int INVALID_COUNTRY_ENTRY = 0x007F; // entry for countries without currency private static final int COUNTRY_WITHOUT_CURRENCY_ENTRY = 0x0080; // mask for simple case country entries private static final int SIMPLE_CASE_COUNTRY_MASK = 0x0000; // mask for simple case country entry final character private static final int SIMPLE_CASE_COUNTRY_FINAL_CHAR_MASK = 0x001F; // mask for simple case country entry default currency digits private static final int SIMPLE_CASE_COUNTRY_DEFAULT_DIGITS_MASK = 0x0060; // shift count for simple case country entry default currency digits private static final int SIMPLE_CASE_COUNTRY_DEFAULT_DIGITS_SHIFT = 5; // mask for special case country entries private static final int SPECIAL_CASE_COUNTRY_MASK = 0x0080; // mask for special case country index private static final int SPECIAL_CASE_COUNTRY_INDEX_MASK = 0x001F; // delta from entry index component in main table to index into special case tables private static final int SPECIAL_CASE_COUNTRY_INDEX_DELTA = 1; // mask for distinguishing simple and special case countries private static final int COUNTRY_TYPE_MASK = SIMPLE_CASE_COUNTRY_MASK | SPECIAL_CASE_COUNTRY_MASK; // mask for the numeric code of the currency private static final int NUMERIC_CODE_MASK = 0x0003FF00; // shift count for the numeric code of the currency private static final int NUMERIC_CODE_SHIFT = 8; // Currency data format version private static final int VALID_FORMAT_VERSION = 1; static { AccessController.doPrivileged(new PrivilegedAction<Void>() { @Override public Void run() { String homeDir = System.getProperty("java.home"); try { String dataFile = homeDir + File.separator + "lib" + File.separator + "currency.data"; try (DataInputStream dis = new DataInputStream( new BufferedInputStream( new FileInputStream(dataFile)))) { if (dis.readInt() != MAGIC_NUMBER) { throw new InternalError("Currency data is possibly corrupted"); } formatVersion = dis.readInt(); if (formatVersion != VALID_FORMAT_VERSION) { throw new InternalError("Currency data format is incorrect"); } dataVersion = dis.readInt(); mainTable = readIntArray(dis, A_TO_Z * A_TO_Z); int scCount = dis.readInt(); scCutOverTimes = readLongArray(dis, scCount); scOldCurrencies = readStringArray(dis, scCount); scNewCurrencies = readStringArray(dis, scCount); scOldCurrenciesDFD = readIntArray(dis, scCount); scNewCurrenciesDFD = readIntArray(dis, scCount); scOldCurrenciesNumericCode = readIntArray(dis, scCount); scNewCurrenciesNumericCode = readIntArray(dis, scCount); int ocCount = dis.readInt(); otherCurrencies = dis.readUTF(); otherCurrenciesDFD = readIntArray(dis, ocCount); otherCurrenciesNumericCode = readIntArray(dis, ocCount); } } catch (IOException e) { throw new InternalError(e); } // look for the properties file for overrides String propsFile = System.getProperty("java.util.currency.data"); if (propsFile == null) { propsFile = homeDir + File.separator + "lib" + File.separator + "currency.properties"; } try { File propFile = new File(propsFile); if (propFile.exists()) { Properties props = new Properties(); try (FileReader fr = new FileReader(propFile)) { props.load(fr); } Set<String> keys = props.stringPropertyNames(); Pattern propertiesPattern = Pattern.compile("([A-Z]{3})\\s*,\\s*(\\d{3})\\s*,\\s*" + "([0-3])\\s*,?\\s*(\\d{4}-\\d{2}-\\d{2}T\\d{2}:" + "\\d{2}:\\d{2})?"); for (String key : keys) { replaceCurrencyData(propertiesPattern, key.toUpperCase(Locale.ROOT), props.getProperty(key).toUpperCase(Locale.ROOT)); } } } catch (IOException e) { info("currency.properties is ignored because of an IOException", e); } return null; } }); } /** * Constants for retrieving localized names from the name providers. */ private static final int SYMBOL = 0; private static final int DISPLAYNAME = 1; /** * Constructs a <code>Currency instance. The constructor is private * so that we can insure that there's never more than one instance for a * given currency. */ private Currency(String currencyCode, int defaultFractionDigits, int numericCode) { this.currencyCode = currencyCode; this.defaultFractionDigits = defaultFractionDigits; this.numericCode = numericCode; } /** * Returns the <code>Currency instance for the given currency code. * * @param currencyCode the ISO 4217 code of the currency * @return the <code>Currency instance for the given currency code * @exception NullPointerException if <code>currencyCode is null * @exception IllegalArgumentException if <code>currencyCode is not * a supported ISO 4217 code. */ public static Currency getInstance(String currencyCode) { return getInstance(currencyCode, Integer.MIN_VALUE, 0); } private static Currency getInstance(String currencyCode, int defaultFractionDigits, int numericCode) { // Try to look up the currency code in the instances table. // This does the null pointer check as a side effect. // Also, if there already is an entry, the currencyCode must be valid. Currency instance = instances.get(currencyCode); if (instance != null) { return instance; } if (defaultFractionDigits == Integer.MIN_VALUE) { // Currency code not internally generated, need to verify first // A currency code must have 3 characters and exist in the main table // or in the list of other currencies. if (currencyCode.length() != 3) { throw new IllegalArgumentException(); } char char1 = currencyCode.charAt(0); char char2 = currencyCode.charAt(1); int tableEntry = getMainTableEntry(char1, char2); if ((tableEntry & COUNTRY_TYPE_MASK) == SIMPLE_CASE_COUNTRY_MASK && tableEntry != INVALID_COUNTRY_ENTRY && currencyCode.charAt(2) - 'A' == (tableEntry & SIMPLE_CASE_COUNTRY_FINAL_CHAR_MASK)) { defaultFractionDigits = (tableEntry & SIMPLE_CASE_COUNTRY_DEFAULT_DIGITS_MASK) >> SIMPLE_CASE_COUNTRY_DEFAULT_DIGITS_SHIFT; numericCode = (tableEntry & NUMERIC_CODE_MASK) >> NUMERIC_CODE_SHIFT; } else { // Check for '-' separately so we don't get false hits in the table. if (currencyCode.charAt(2) == '-') { throw new IllegalArgumentException(); } int index = otherCurrencies.indexOf(currencyCode); if (index == -1) { throw new IllegalArgumentException(); } defaultFractionDigits = otherCurrenciesDFD[index / 4]; numericCode = otherCurrenciesNumericCode[index / 4]; } } Currency currencyVal = new Currency(currencyCode, defaultFractionDigits, numericCode); instance = instances.putIfAbsent(currencyCode, currencyVal); return (instance != null ? instance : currencyVal); } /** * Returns the <code>Currency instance for the country of the * given locale. The language and variant components of the locale * are ignored. The result may vary over time, as countries change their * currencies. For example, for the original member countries of the * European Monetary Union, the method returns the old national currencies * until December 31, 2001, and the Euro from January 1, 2002, local time * of the respective countries. * <p> * The method returns <code>null for territories that don't * have a currency, such as Antarctica. * * @param locale the locale for whose country a <code>Currency * instance is needed * @return the <code>Currency instance for the country of the given * locale, or {@code null} * @exception NullPointerException if <code>locale or its country * code is {@code null} * @exception IllegalArgumentException if the country of the given {@code locale} * is not a supported ISO 3166 country code. */ public static Currency getInstance(Locale locale) { String country = locale.getCountry(); if (country == null) { throw new NullPointerException(); } if (country.length() != 2) { throw new IllegalArgumentException(); } char char1 = country.charAt(0); char char2 = country.charAt(1); int tableEntry = getMainTableEntry(char1, char2); if ((tableEntry & COUNTRY_TYPE_MASK) == SIMPLE_CASE_COUNTRY_MASK && tableEntry != INVALID_COUNTRY_ENTRY) { char finalChar = (char) ((tableEntry & SIMPLE_CASE_COUNTRY_FINAL_CHAR_MASK) + 'A'); int defaultFractionDigits = (tableEntry & SIMPLE_CASE_COUNTRY_DEFAULT_DIGITS_MASK) >> SIMPLE_CASE_COUNTRY_DEFAULT_DIGITS_SHIFT; int numericCode = (tableEntry & NUMERIC_CODE_MASK) >> NUMERIC_CODE_SHIFT; StringBuilder sb = new StringBuilder(country); sb.append(finalChar); return getInstance(sb.toString(), defaultFractionDigits, numericCode); } else { // special cases if (tableEntry == INVALID_COUNTRY_ENTRY) { throw new IllegalArgumentException(); } if (tableEntry == COUNTRY_WITHOUT_CURRENCY_ENTRY) { return null; } else { int index = (tableEntry & SPECIAL_CASE_COUNTRY_INDEX_MASK) - SPECIAL_CASE_COUNTRY_INDEX_DELTA; if (scCutOverTimes[index] == Long.MAX_VALUE || System.currentTimeMillis() < scCutOverTimes[index]) { return getInstance(scOldCurrencies[index], scOldCurrenciesDFD[index], scOldCurrenciesNumericCode[index]); } else { return getInstance(scNewCurrencies[index], scNewCurrenciesDFD[index], scNewCurrenciesNumericCode[index]); } } } } /** * Gets the set of available currencies. The returned set of currencies * contains all of the available currencies, which may include currencies * that represent obsolete ISO 4217 codes. The set can be modified * without affecting the available currencies in the runtime. * * @return the set of available currencies. If there is no currency * available in the runtime, the returned set is empty. * @since 1.7 */ public static Set<Currency> getAvailableCurrencies() { synchronized(Currency.class) { if (available == null) { available = new HashSet<>(256); // Add simple currencies first for (char c1 = 'A'; c1 <= 'Z'; c1 ++) { for (char c2 = 'A'; c2 <= 'Z'; c2 ++) { int tableEntry = getMainTableEntry(c1, c2); if ((tableEntry & COUNTRY_TYPE_MASK) == SIMPLE_CASE_COUNTRY_MASK && tableEntry != INVALID_COUNTRY_ENTRY) { char finalChar = (char) ((tableEntry & SIMPLE_CASE_COUNTRY_FINAL_CHAR_MASK) + 'A'); int defaultFractionDigits = (tableEntry & SIMPLE_CASE_COUNTRY_DEFAULT_DIGITS_MASK) >> SIMPLE_CASE_COUNTRY_DEFAULT_DIGITS_SHIFT; int numericCode = (tableEntry & NUMERIC_CODE_MASK) >> NUMERIC_CODE_SHIFT; StringBuilder sb = new StringBuilder(); sb.append(c1); sb.append(c2); sb.append(finalChar); available.add(getInstance(sb.toString(), defaultFractionDigits, numericCode)); } } } // Now add other currencies StringTokenizer st = new StringTokenizer(otherCurrencies, "-"); while (st.hasMoreElements()) { available.add(getInstance((String)st.nextElement())); } } } @SuppressWarnings("unchecked") Set<Currency> result = (Set Other Java examples (source code examples)Here is a short list of links related to this Java Currency.java source code file: |
... this post is sponsored by my books ... | |
#1 New Release! |
FP Best Seller |
Copyright 1998-2021 Alvin Alexander, alvinalexander.com
All Rights Reserved.
A percentage of advertising revenue from
pages under the /java/jwarehouse
URI on this website is
paid back to open source projects.