hashmoney的简单介绍

作为虚拟币行业人士而言，我们经常都会说到hashmoney时有很多细节是需要注意的。你知道？今天就让小编跟你们说说吧！

java 编程买水果钱刚好用完问题，求思路

for(int i=0;i=n/59;i ){

    for(int j=0;j=n/32;j ){

    ...

if((i j ...)==n){

    则每种水果是 i 个 、j个  ...

}

    }

}

在一个HashMap中,保存的有Long型和String型的对象,其中的数字为金额,有正有负,请？

在一个HashMap中,保存的有Long型和String型的对象,其中的数字为金额,有正有负,请？

class MyClass{

Integer id;

String name;

Long money;

public MyClass(String name,Long money){

this.name=name;

this.money =money;

}

}

MapInteger ,MyClass map = new HashMap();

map.put(1,new MyClass("zpl",-2345.34));

map.put(2,new MyClass("wangyan",2345.34));

JAVA 递归找零钱

看了楼上的写法后，不甚满意，于是自己写了一种。

这个题目很有意思，相当有意思。

加上了比较详细的注释。

你试一试。

这种方法你能很明显的看出递归的特征。

可以随意传要找钱的总数，以及硬币面额可以增加或者减少。但是

硬币的面额要由小到大排列，就ok

注释加的有点多。。看起来有点累赘。不过能容易看。

package file;

import java.util.ArrayList;

import java.util.List;

/**

* 递归得到找钱方案个数

* 思路为：

* 定义待找钱币类型。默认从小到大排列。

* 传入参数后，先获得最大的硬币面值。通过整除，得到可以有几种找钱情况

* 递归调用找钱，因为排除了最大面额硬币后的可找硬币以余额都发生了变化。可以看作一次新的找钱

* 最终得到所有的找钱方案。封装到List中返回。

* @version TestRePay.java v. 1.0.0 2010-10-26

* @author Andy

*/

public class TestRePay {

public static void main(String[]args){

int i = 150;

int[] coinType = new int[]{1,5,10,25,50};

//调用递归方法

ListString allResult = reCoins(coinType, i);

System.out.println("找钱方案的个数为：" allResult.size());

for(int j = 1 ,k = allResult.size(); j=k;j ){

System.out.println(" 第" j "种找钱方案为：" allResult.get(j-1));

}

}

/**

* 通过递归，得到所有的方案数量

* author Andy

* date 2010-10-26 下午01:30:06

* @param coinType 可以找给客户的钱币的类型 为int数组

* @param totalMoney 待找钱的数量

* @return

*/

public static ListString reCoins(int[]coinType , int totalMoney){

//获得最后一个，也就是默认为最大的一个钱币类型

int lastCoin = coinType[coinType.length-1];

//通过数组复制获得下一级调用时候的硬币类型

int[] newCoinType = new int[coinType.length-1];

System.arraycopy(coinType, 0, newCoinType, 0, newCoinType.length);

//获得针对当前硬币，也就是这个lastCoin 有几种找钱情况

int times = totalMoney/lastCoin;

ListString resultList = new ArrayListString();

//如果当前硬币的面值大于余额。但是手中还有更小面值的硬币，则递归调用找钱。

if(times==0coinType.length!=0){

ListString childList = reCoins(newCoinType, totalMoney);

resultList.addAll(childList);

//进行遍历，得到带找钱的值

}else{

//最小面值了，所以，直接返回值

if(coinType.length==1){

resultList.add(" 1分*" totalMoney "个 ");

}else{

//不是最小面值，所以，要遍历下

for(int i=1;i=times;i ){

ListString childList = null;

int remainder = totalMoney-lastCoin*i;//新余额

if(remainder != 0){

childList = reCoins(newCoinType, remainder);

for(String r:childList){

r = " " lastCoin "分*" i "个 " r;

resultList.add(r);

}

}else{

resultList.add(" " lastCoin "分*" i "个 ");

}

}

}

}

return resultList;

}

}

加油，java的路 还有很长哦，呵呵

区块链科普

区块链的概念这么火，竟然没有人能很好的解释基本概念。

到找了一个网站，用图示的方法解释了一些基本概念。 blockchian demo

以下是涉及到的概念。

data  hash   block   nouce  mine

prev  distributed   peer   token  coinbase

理解如下：

1 hash和data的关系。

不同的data对应不同的hash，输入相同的data，会出现相同的hash，但是你无法从hash反推出data是什么。这是由数学算法决定的。

没有数据或者海量数据，hash依旧是那么多位数。

2 block。

区块。简易版的组成：block序号。nonce。data。hash。mine。

3 nonce。mine。

nonce与hash的关系。nonce是一组数字，不同的nonce对应不同的hash,而且是一一对应。也就是说，hash改变，nonce也必须改变。

当你在block里面改变你的data时，你的hash改变了，hash是自动改变的。但是同时，你的nonce并没有改变，于是它与hash不匹配。这个时候，你的这个block就会被判定无效（invalidate）。

这个时候，通过挖矿（mine），运行算法，来给当前的hash匹配到相应的nonce，使这个block生效。mine需要耗费计算资源。

nonce被翻译成碰撞数，也是生动。

4 blockchain

blockchain就是block的链条。他们通过prev，也就是记录前一个block的hash链接起来。因此，第一个block没有prvious hash。

在blockchain中，跟block一样，如果你改变任意一个节点的data，其hash值改变后，为了让它validate，你需要mine，以匹配到nonce。我试着mine了后，发现改变data后的hash变化后，mine后的hash还会继续改变，跟nonce都变化了，这样才validate了。这里并不明白为什么。

同时，由于其后一个block继承到了新的prev hash，整个block变得invalidate，需要mine。也就是说，被改变后的block连同其后的每一个block都需要mine，才能validate。

5 distributed 分布式

一条区块链会有n个peer，是其完全相同的复制品。我的理解是：每个人都有一个完整的、与其他人相同的记录在区块链的账本。当一个blockchain里的数据改变时，它需要使用mine的方式重新使得整个blockchain有效，但与此同时，系统会发现它与其他的blockchain是不一会的（比对最后一个block的hash等就可以了），这时会判定其他多数的blockchain是有效的，用少数服从多数原则判定账本，也就是说，这个blockchain的改变会视为无效。

6  token（代币）

token的英英解释是这样的：

 A  token  is a round flat piece of metal or plastic that is sometimes used instead of money。

翻译成代币也算是准确。

token就是记录在block中data里面的交易数据，包括金额，以及from 和to。

每个block里的token记录的都是所有的转账记录。（目前的理解）也就是说，当你进行了一笔交易时，这个交易记录会被广播到所有peer的block中的token记录里。

7 coinbase

可以理解为币池，就是流通的货币总量。就是这个blockchain里面的token总额或者叫做coin有多少。

JAVA编程 金额转换

不知道这个是不是您需要的答案

package test.format;

import java.text.Numberformat;

import java.util.HashMap;

public class SimpleMoneyformat {

public static final String EMPTY = "";

public static final String ZERO = "零";

public static final String ONE = "壹";

public static final String TWO = "贰";

public static final String THREE = "叁";

public static final String FOUR = "肆";

public static final String FIVE = "伍";

public static final String SIX = "陆";

public static final String SEVEN = "柒";

public static final String EIGHT = "捌";

public static final String NINE = "玖";

public static final String TEN = "拾";

public static final String HUNDRED = "佰";

public static final String THOUSAND = "仟";

public static final String TEN_THOUSAND = "万";

public static final String HUNDRED_MILLION = "亿";

public static final String YUAN = "元";

public static final String JIAO = "角";

public static final String FEN = "分";

public static final String DOT = ".";

private static SimpleMoneyformat formatter = null;

private HashMap chineseNumberMap = new HashMap();

private HashMap chineseMoneyPattern = new HashMap();

private Numberformat numberformat = Numberformat.getInstance();

private SimpleMoneyformat() {

numberformat.setMaximumFractionDigits(4);

numberformat.setMinimumFractionDigits(2);

numberformat.setGroupingUsed(false);

chineseNumberMap.put("0", ZERO);

chineseNumberMap.put("1", ONE);

chineseNumberMap.put("2", TWO);

chineseNumberMap.put("3", THREE);

chineseNumberMap.put("4", FOUR);

chineseNumberMap.put("5", FIVE);

chineseNumberMap.put("6", SIX);

chineseNumberMap.put("7", SEVEN);

chineseNumberMap.put("8", EIGHT);

chineseNumberMap.put("9", NINE);

chineseNumberMap.put(DOT, DOT);

chineseMoneyPattern.put("1", TEN);

chineseMoneyPattern.put("2", HUNDRED);

chineseMoneyPattern.put("3", THOUSAND);

chineseMoneyPattern.put("4", TEN_THOUSAND);

chineseMoneyPattern.put("5", TEN);

chineseMoneyPattern.put("6", HUNDRED);

chineseMoneyPattern.put("7", THOUSAND);

chineseMoneyPattern.put("8", HUNDRED_MILLION);

}

public static SimpleMoneyformat getInstance() {

if (formatter == null)

formatter = new SimpleMoneyformat();

return formatter;

}

public String format(String moneyStr) {

checkPrecision(moneyStr);

String result;

result = convertToChineseNumber(moneyStr);

result = addUnitsToChineseMoneyString(result);

return result;

}

public String format(double moneyDouble) {

return format(numberformat.format(moneyDouble));

}

public String format(int moneyInt) {

return format(numberformat.format(moneyInt));

}

public String format(long moneyLong) {

return format(numberformat.format(moneyLong));

}

public String format(Number moneyNum) {

return format(numberformat.format(moneyNum));

}

private String convertToChineseNumber(String moneyStr) {

String result;

StringBuffer cMoneyStringBuffer = new StringBuffer();

for (int i = 0; i moneyStr.length(); i ) {

cMoneyStringBuffer.append(chineseNumberMap.get(moneyStr.substring(i, i 1)));

}

//拾佰仟万亿等都是汉字里面才有的单位，加上它们

int indexOfDot = cMoneyStringBuffer.indexOf(DOT);

int moneyPatternCursor = 1;

for (int i = indexOfDot - 1; i 0; i--) {

cMoneyStringBuffer.insert(i, chineseMoneyPattern.get(EMPTY moneyPatternCursor));

moneyPatternCursor = moneyPatternCursor == 8 ? 1 : moneyPatternCursor 1;

}

String fractionPart = cMoneyStringBuffer.substring(cMoneyStringBuffer.indexOf("."));

cMoneyStringBuffer.delete(cMoneyStringBuffer.indexOf("."), cMoneyStringBuffer.length());

while (cMoneyStringBuffer.indexOf("零拾") != -1) {

cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf("零拾"), cMoneyStringBuffer.indexOf("零拾") 2, ZERO);

}

while (cMoneyStringBuffer.indexOf("零佰") != -1) {

cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf("零佰"), cMoneyStringBuffer.indexOf("零佰") 2, ZERO);

}

while (cMoneyStringBuffer.indexOf("零仟") != -1) {

cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf("零仟"), cMoneyStringBuffer.indexOf("零仟") 2, ZERO);

}

while (cMoneyStringBuffer.indexOf("零万") != -1) {

cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf("零万"), cMoneyStringBuffer.indexOf("零万") 2, TEN_THOUSAND);

}

while (cMoneyStringBuffer.indexOf("零亿") != -1) {

cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf("零亿"), cMoneyStringBuffer.indexOf("零亿") 2, HUNDRED_MILLION);

}

while (cMoneyStringBuffer.indexOf("零零") != -1) {

cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf("零零"), cMoneyStringBuffer.indexOf("零零") 2, ZERO);

}

if (cMoneyStringBuffer.lastIndexOf(ZERO) == cMoneyStringBuffer.length() - 1)

cMoneyStringBuffer.delete(cMoneyStringBuffer.length() - 1, cMoneyStringBuffer.length());

cMoneyStringBuffer.append(fractionPart);

result = cMoneyStringBuffer.toString();

return result;

}

private String addUnitsToChineseMoneyString(String moneyStr) {

String result;

StringBuffer cMoneyStringBuffer = new StringBuffer(moneyStr);

int indexOfDot = cMoneyStringBuffer.indexOf(DOT);

cMoneyStringBuffer.replace(indexOfDot, indexOfDot 1, YUAN);

java实现金额转换，阿拉伯数字的金额转换成中国传统的形式

直接通过以下接口类方法实现即可：

import java.math.BigDecimal;

/**

* 金额工具类

*

* @author zn

*

* @Date 2013-2-1

* @Email zn.share@gmail.com

*/

public class MoneyUtil {

private static final int DFT_SCALE = 2;

/** 大写数字 */

private static final String[] NUMBERS = { "零", "壹", "贰", "叁", "肆", "伍",

"陆", "柒", "捌", "玖" };

/** 整数部分的单位 */

private static final String[] IUNIT = { "元", "拾", "佰", "仟", "万", "拾", "佰",

"仟", "亿", "拾", "佰", "仟", "万", "拾", "佰", "仟" };

/** 小数部分的单位 */

private static final String[] DUNIT = { "角", "分", "厘" };

/**

* 得到大写金额。

*/

public static String toChinese(String str) {

str = str.replaceAll(",", "");// 去掉","

String integerStr;// 整数部分数字

String decimalStr;// 小数部分数字

// 初始化：分离整数部分和小数部分

if (str.indexOf(".") 0) {

integerStr = str.substring(0, str.indexOf("."));

decimalStr = str.substring(str.indexOf(".") 1);

} else if (str.indexOf(".") == 0) {

integerStr = "";

decimalStr = str.substring(1);

} else {

integerStr = str;

decimalStr = "";

}

// integerStr去掉首0，不必去掉decimalStr的尾0(超出部分舍去)

if (!integerStr.equals("")) {

integerStr = Long.toString(Long.parseLong(integerStr));

if (integerStr.equals("0")) {

integerStr = "";

}

}

// overflow超出处理能力，直接返回

if (integerStr.length() IUNIT.length) {

System.out.println(str ":超出处理能力");

return str;

}

int[] integers = toArray(integerStr);// 整数部分数字

boolean isMust5 = isMust5(integerStr);// 设置万单位

int[] decimals = toArray(decimalStr);// 小数部分数字

return getChineseInteger(integers, isMust5)

getChineseDecimal(decimals);

}

/**

* 整数部分和小数部分转换为数组，从高位至低位

*/

private static int[] toArray(String number) {

int[] array = new int[number.length()];

for (int i = 0; i number.length(); i ) {

array[i] = Integer.parseInt(number.substring(i, i 1));

}

return array;

}

/**

* 得到中文金额的整数部分。

*/

private static String getChineseInteger(int[] integers, boolean isMust5) {

StringBuffer chineseInteger = new StringBuffer("");

int length = integers.length;

for (int i = 0; i length; i ) {

// 0出现在关键位置：1234(万)5678(亿)9012(万)3456(元)

// 特殊情况：10(拾元、壹拾元、壹拾万元、拾万元)

String key = "";

if (integers[i] == 0) {

if ((length - i) == 13)// 万(亿)(必填)

key = IUNIT[4];

else if ((length - i) == 9)// 亿(必填)

key = IUNIT[8];

else if ((length - i) == 5 isMust5)// 万(不必填)

key = IUNIT[4];

else if ((length - i) == 1)// 元(必填)

key = IUNIT[0];

// 0遇非0时补零，不包含最后一位

if ((length - i) 1 integers[i 1] != 0)

key = NUMBERS[0];

}

chineseInteger.append(integers[i] == 0 ? key

: (NUMBERS[integers[i]] IUNIT[length - i - 1]));

}

return chineseInteger.toString();

}

/**

* 得到中文金额的小数部分。

*/

private static String getChineseDecimal(int[] decimals) {

StringBuffer chineseDecimal = new StringBuffer("");

for (int i = 0; i decimals.length; i ) {

// 舍去3位小数之后的

if (i == 3)

break;

chineseDecimal.append(decimals[i] == 0 ? ""

: (NUMBERS[decimals[i]] DUNIT[i]));

}

return chineseDecimal.toString();

}

/**

* 判断第5位数字的单位"万"是否应加。

*/

private static boolean isMust5(String integerStr) {

int length = integerStr.length();

if (length 4) {

String subInteger = "";

if (length 8) { // TODO 12-9-17

// 取得从低位数，第5到第8位的字串

subInteger = integerStr.substring(length - 8, length - 4);

} else {

subInteger = integerStr.substring(0, length - 4);

}

return Integer.parseInt(subInteger) 0;

} else {

return false;

}

}

/**

* BigDecimal 相乘,四舍五入保留0位

*

* @param a

* @param b

* @return a*b

*/

public static BigDecimal mutiply(String a, String b, int roundingMode) {

BigDecimal bd = new BigDecimal(a);

return bd.multiply(new BigDecimal(b)).setScale(DFT_SCALE, roundingMode);

}

/**

* BigDecimal 相除,四舍五入保留两位

*

* @param a

* @param b

* @return a/b

*/

public static BigDecimal div(String a, String b, int roundingMode) {

BigDecimal decimal1 = new BigDecimal(a);

BigDecimal decimal2 = new BigDecimal(b);

return decimal1.divide(decimal2, DFT_SCALE, roundingMode);

}

/**

* BigDecimal 相加,四舍五入保留两位

*

* @param a

* @param b

* @return a b

*/

public static BigDecimal sum(String a, String b, int roundingMode) {

BigDecimal decimal1 = new BigDecimal(a);

BigDecimal decimal2 = new BigDecimal(b);

// DecimalFormat format = new DecimalFormat("#0.00");

return decimal1.add(decimal2).setScale(DFT_SCALE, roundingMode);

}

/**

* BigDecimal 相减,四舍五入保留两位

*

* @param a

* @param b

* @return a b

*/

public static BigDecimal sub(String a, String b, int roundingMode) {

BigDecimal decimal1 = new BigDecimal(a);

BigDecimal decimal2 = new BigDecimal(b);

// DecimalFormat format = new DecimalFormat("#0.00");

return decimal1.subtract(decimal2).setScale(DFT_SCALE, roundingMode);

}

/**

* 100.00 为10000

*

* @param a

* @return

*/

public static BigDecimal format(String a, int roundingMode) {

return new BigDecimal(a).multiply(new BigDecimal(100)).setScale(0,

roundingMode);

}

public static void main(String[] args) {

String number = "54452";

System.out.println(number " " MoneyUtil.toChinese(number));

number = "30200";

System.out.println(number " " MoneyUtil.toChinese(number));

number = "30000.05";

System.out.println(number " " MoneyUtil.toChinese(number));

number = "30000.00";

System.out.println(number " " MoneyUtil.toChinese(number));

}

}

备注：最后面的main方法是具体的调用。

相信经过帮企客小编对hashmoney和的介绍，你对hashmoney了解更加地透彻了，感谢你对我们地支持与关注！