Java Currency类代码示例

import org.jscience.economics.money.Currency; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Override
public Appendable format(Amount arg0, Appendable arg1)
        throws IOException {
    if (arg0.getUnit() instanceof Currency)
        return formatMoney(arg0, arg1);
    if (arg0.isExact()) {
        TypeFormat.format(arg0.getExactValue(), arg1);
        arg1.append(' ');
        return UnitFormat.getInstance().format(arg0.getUnit(), arg1);
    }
    double value = arg0.getEstimatedValue();
    double error = arg0.getAbsoluteError();
    int log10Value = (int) MathLib.floor(MathLib.log10(MathLib
            .abs(value)));
    int log10Error = (int) MathLib.floor(MathLib.log10(error));
    int digits = log10Value - log10Error - 1; // Exact digits.

    boolean scientific = (MathLib.abs(value) >= 1E6)
            || (MathLib.abs(value) < 1E-6);
    boolean showZeros = true;
    TypeFormat.format(value, digits, scientific, showZeros, arg1);
    arg1.append(' ');
    return UnitFormat.getInstance().format(arg0.getUnit(), arg1);
}
 

import org.jscience.economics.money.Currency; //导入依赖的package包/类
public PortfolioController(Portfolio portfolio, Market market) {
    this.props = new Properties(); // TODO i18n, use ResourceBundle or Messages where possible
	this.market = market;
	this.portfolio = portfolio;        
    quoteFactory = QuoteManager.getQuoteFactory();
    
    try {
    	InputStream in = PortfolioController.class.getResourceAsStream 
    	 ("/currency.properties");
    	props.load(in);
    	
    	if (Currency.getReferenceCurrency() != null) {
    		labelCurrency(Currency.getReferenceCurrency());
    	}       	
    } catch (IOException ie) {
    	logger.warn("Error loading properties", ie); 
    }
}
 

import org.jscience.economics.money.Currency; //导入依赖的package包/类
public Market(String symbol, String name, Currency curr,
  Map<String, String> markets, Map<String, Object> exchangeRates) {
	
	if (Currency.getReferenceCurrency() == null) {
		logger.info("Setting Reference Currency to " +
				String.valueOf(curr) + "...");
		curr.setExchangeRate(1);
		Currency.setReferenceCurrency(curr);
	} else {
		if (curr.equals(Currency.getReferenceCurrency())) {
			logger.info(String.valueOf(curr) + " is the Reference Currency.");
			curr.setExchangeRate(1);
		}
	}
	
	this.name = name;
	this.symbol = symbol;
	this.currency = curr;
	this.knownMarkets = markets;		
	this.currencyExchangeRates = exchangeRates;
}
 

import org.jscience.economics.money.Currency; //导入依赖的package包/类
public static void main(String[] args) throws IOException, ClassNotFoundException {
    A a = new A(2L, Amount.valueOf(3.0, Currency.EUR));
    File outputFile = File.createTempFile("prefix", "suffix");
    FileOutputStream fileOutputStream = new FileOutputStream(outputFile);
    try (ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream)) {
        objectOutputStream.writeObject(a);
        objectOutputStream.flush();
    }
    FileInputStream fileInputStream = new FileInputStream(outputFile);
    A aReloaded;
    try (ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream)) {
        aReloaded = (A) objectInputStream.readObject();
    }
    System.out.println(aReloaded.toString());
}
 

import org.jscience.economics.money.Currency; //导入依赖的package包/类
private void labelCurrency(String symbol, Currency curr) {
//String label = market.getCurrencyLabels().get(cSymbol);
String label = props.getProperty(symbol, "");
if (label != null && label.length()>0) {
	UnitFormat.getInstance().label(curr, label);
}
  }
 

import org.jscience.economics.money.Currency; //导入依赖的package包/类
/**
 * @param args the command line arguments
 */
public static void main(String[] args) throws IOException {
    String databaseDir = System.getProperty("databaseDir");
    File databaseDirFile;
    if(databaseDir == null) {
        databaseDirFile = File.createTempFile("prefix", "suffix");
        databaseDirFile.delete();
        databaseDirFile.mkdirs();
    }else {
        databaseDirFile = new File(databaseDir);
        if(!databaseDirFile.exists()) {
            databaseDirFile.mkdirs();
        }
    }
    LOGGER.info(String.format("database directory is: %s", databaseDirFile.getAbsolutePath()));
    if(!databaseDirFile.exists()) {
        databaseDirFile.mkdirs();
    }
    String databaseName = System.getProperty("databaseName");
        //allows resuage of database if databaseName system property is
        //specified
    File databaseFile;
    if(databaseName == null) {
        databaseFile = File.createTempFile("prefix", "suffix", databaseDirFile);
        databaseFile.delete();
        databaseFile.mkdir();
    } else {
        databaseFile = new File(databaseDirFile, databaseName);
        if(!databaseFile.exists()) {
            databaseFile.mkdir();
        }else if(!databaseFile.isDirectory()) {
            throw new IllegalArgumentException();
        }
    }
    String action = System.getProperty("drop", "drop-and-create");
    boolean needCreation = !databaseFile.exists() || (databaseFile.exists() && databaseFile.list().length == 0);
    EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory("test", new HashMap() {
        {
            put("javax.persistence.jdbc.url",
                    String.format("jdbc:derby:memory:%s%s",
                            databaseFile.getAbsolutePath(),
                            needCreation ? ";create=true": ""));
            put("javax.persistence.jdbc.user",
                    "sa");
            put("javax.persistence.jdbc.driver",
                    "org.apache.derby.jdbc.EmbeddedDriver");
            put("javax.persistence.jdbc.password",
                    "");
            put("javax.persistence.schema-generation.database.action",
                    action);
        }
    });
    EntityManager entityManager = entityManagerFactory.createEntityManager();
    A a = new A(1L, Amount.valueOf(1, Currency.EUR));
    entityManager.getTransaction().begin();
    entityManager.persist(a);
    entityManager.getTransaction().commit();
}
 

import org.jscience.economics.money.Currency; //导入依赖的package包/类
protected PortfolioItemBean(Currency curr) {
	this.currency = curr;
}
 

import org.jscience.economics.money.Currency; //导入依赖的package包/类
public void setCurrentValue(double currentValue) {
    //this.currentValue = currentValue;
	this.currentAmount = Amount.valueOf(currentValue, Currency.getReferenceCurrency());
}
 

import org.jscience.economics.money.Currency; //导入依赖的package包/类
/**
 * @return the Quote value as Amount
 */
public Amount<Money> getQuoteAmount() {
	return Amount.valueOf(quote.getValue(), Currency.getReferenceCurrency());
}
 

import org.jscience.economics.money.Currency; //导入依赖的package包/类
/**
 * @return the Quote change as Amount
 */
public Amount<Money> getQuoteChangeAmount() {
	return Amount.valueOf(quote.getChange(), Currency.getReferenceCurrency());
}
 

import org.jscience.economics.money.Currency; //导入依赖的package包/类
/**
 * @return Gain or Loss as Amount
 */
public Amount<Money> getGainLossAmount() {
	return Amount.valueOf(gainLoss, Currency.getReferenceCurrency());
}
 

import org.jscience.economics.money.Currency; //导入依赖的package包/类
/**
 * @return Quote Opening Price as Amount
 */
public Amount<Money> getQuoteOpenAmount() {
	return Amount.valueOf(quote.getOpenPrice(), Currency.getReferenceCurrency());
}
 

import org.jscience.economics.money.Currency; //导入依赖的package包/类
/**
 * @return the currency
 */
public Currency getCurrency() {
	return currency;
}
 

import org.jscience.economics.money.Currency; //导入依赖的package包/类
/**
 * @param currency the currency to set
 */
public void setCurrency(Currency currency) {
	this.currency = currency;
}
 

import org.jscience.economics.money.Currency; //导入依赖的package包/类
public Portfolio(double cashVal, LinkedHashMap<String, String> sharesPerSymbol,
		 Currency curr) {
    this.sharesPerSymbol =  sharesPerSymbol;
    this.currency = curr;
    this.setCash(cashVal);
}