simplemoneyformat.java

将输入的金额数字转化为人民币的大写

package test;

import java.util.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.text.NumberFormat;
import java.text.SimpleDateFormat;
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);
		//System.out.println(cMoneyStringBuffer.toString());
		result = cMoneyStringBuffer.toString();
		return result;
	}

	private String addUnitsToChineseMoneyString(String moneyStr)
	{
		String result = null;
		StringBuffer cMoneyStringBuffer = new StringBuffer(moneyStr);
		int indexOfDot = cMoneyStringBuffer.indexOf(DOT);
		cMoneyStringBuffer.replace(indexOfDot, indexOfDot + 1, YUAN);
		cMoneyStringBuffer.insert(cMoneyStringBuffer.length() - 1, JIAO);
		cMoneyStringBuffer.insert(cMoneyStringBuffer.length(), FEN);
		if (cMoneyStringBuffer.indexOf("零角零分") != -1)//没有零头，加整
			cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf("零角零分"),
					cMoneyStringBuffer.length(), "整");
		else if (cMoneyStringBuffer.indexOf("零分") != -1)//没有零分，加整
			cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf("零分"),
					cMoneyStringBuffer.length(), "整");
		else
		{
			if (cMoneyStringBuffer.indexOf("零角") != -1)
				cMoneyStringBuffer.delete(cMoneyStringBuffer.indexOf("零角"),
						cMoneyStringBuffer.indexOf("零角") + 2);
			//	      tmpBuffer.append("整");
		}
		result = cMoneyStringBuffer.toString();
		return result;
	}

	private void checkPrecision(String moneyStr)
	{
		int fractionDigits = moneyStr.length() - moneyStr.indexOf(DOT) - 1;
		if (fractionDigits > 2)
			throw new RuntimeException("金额" + moneyStr + "的小数位多于两位。"); //精度不能比分低
	}

	public static void main(String args[])
	{
//		System.out.println(getInstance().format(new Double(1500)));
		String format1="mm-dd-yyyy kk:mm a";
		String format2="yyyy:MM:dd hh:mm:ss";
		SimpleDateFormat formatter = new SimpleDateFormat(format2);
		Date now = new Date();
		System.out.println(formatter.format(now));
	}
}
//================================排序======================
class Sort
{

	public static void swap(int[] data, int i, int j)
	{
		int tmp = 0;
		tmp = data[i];
		data[i] = data[j];
		data[j] = tmp;
	}

	// 插入排序
	public static void sort1(int[] data)
	{
		for (int i = 1; i < data.length; i++)
		{
			for (int j = i; (j > 0) && (data[j] < data[j - 1]); j--)
			{
				swap(data, j, j - 1);
			}
		}
	}

	// 冒泡排序
	public static void sort2(int[] data)
	{
		for (int i = 0; i < data.length; i++)
		{
			for (int j = data.length - 1; j > i; j--)
			{
				if (data[j] < data[j - 1])
				{
					swap(data, j, j - 1);
				}
			}
		}
	}

	// 选择排序
	public static void sort3(int[] data)
	{
		for (int i = 0; i < data.length; i++)
		{
			int lowIndex = i;
			for (int j = data.length - 1; j > i; j--)
			{
				if (data[j] < data[lowIndex])
				{
					lowIndex = j;
				}
			}
			swap(data, i, lowIndex);
		}
	}

	// Shell排序
	public static void sort4(int[] data)
	{
		for (int i = data.length / 2; i > 2; i /= 2)
		{
			for (int j = 0; j < i; j++)
			{
				for (int k = i; (k > 0) && (data[k] < data[k - 1]); k -= i)
				{
					swap(data, j, j - 1);
				}
			}
		}
	}

	// 快速排序
	public static void sort5(int[] data)
	{
		quickSort(data, 0, data.length - 1);
	}

	private static void quickSort(int[] data, int i, int j)
	{
		int pivotIndex = (i + j) / 2;
		swap(data, pivotIndex, j);

		int k = partition(data, i - 1, j, data[j]);
		swap(data, k, j);
		if ((k - i) > 1)
			quickSort(data, i, k - 1);
		if ((j - k) > 1)
			quickSort(data, k + 1, j);

	}

	private static int partition(int[] data, int l, int r, int pivot)
	{
		do
		{
			while (data[++l] < pivot)
				;
			while ((r != 0) && data[--r] > pivot)
				;
			swap(data, l, r);
		} while (l < r);
		swap(data, l, r);
		return l;
	}

	// 归并排序
	public static void sort6(int[] data)
	{
		int[] temp = new int[data.length];
		mergeSort(data, temp, 0, data.length - 1);
	}

	private static void mergeSort(int[] data, int[] temp, int l, int r)
	{
		int mid = (l + r) / 2;
		if (l == r)
			return;
		mergeSort(data, temp, l, mid);
		mergeSort(data, temp, mid + 1, r);
		for (int i = l; i <= r; i++)
		{
			temp[i] = data[i];
		}
		int i1 = l;
		int i2 = mid + 1;
		for (int cur = l; cur <= r; cur++)
		{
			if (i1 == mid + 1)
				data[cur] = temp[i2++];
			else if (i2 > r)
				data[cur] = temp[i1++];
			else if (temp[i1] < temp[i2])
				data[cur] = temp[i1++];
			else
				data[cur] = temp[i2++];
		}
	}

	// 堆排序
	public static void sort7(int[] data)
	{
		MaxHeap h = new MaxHeap();
		h.init(data);
		for (int i = 0; i < data.length; i++)
			h.remove();
		System.arraycopy(h.queue, 1, data, 0, data.length);
	}

	private static class MaxHeap
	{

		void init(int[] data)
		{
			this.queue = new int[data.length + 1];
			for (int i = 0; i < data.length; i++)
			{
				queue[++size] = data[i];
				fixUp(size);
			}
		}

		private int size = 0;

		private int[] queue;

		public int get()
		{
			return queue[1];
		}

		public void remove()
		{
			swap(queue, 1, size--);
			fixDown(1);
		}

		// fixdown
		private void fixDown(int k)
		{
			int j;
			while ((j = k << 1) <= size)
			{
				if (j < size && queue[j] < queue[j + 1])
					j++;
				if (queue[k] > queue[j]) // 不用交
					break;
				swap(queue, j, k);
				k = j;
			}
		}

		private void fixUp(int k)
		{
			while (k > 1)
			{
				int j = k >> 1;
				if (queue[j] > queue[k])
					break;
				swap(queue, j, k);
				k = j;
			}
		}
	}
}