Java方法记录

1.XML文件转换为Map、List集合

/**
	 * 解析xml字符串成List
	 * 
	 * @param
	 * @return List
	 */
	public static List parseForList(String xmlDoc) {
		// 创建一个新的字符串
		StringReader xmlString = new StringReader(xmlDoc);
		// 创建新的输入源SAX 解析器将使用 InputSource 对象来确定如何读取 XML 输入
		InputSource source = new InputSource(xmlString);
		// 创建一个新的SAXBuilder
		SAXBuilder saxb = new SAXBuilder();

		List result = null;
		try {
			result = new ArrayList();
			// 通过输入源构造一个Document
			Document doc = saxb.build(source);
			// 取的根元素
			Element root = doc.getRootElement();

			// 得到根元素所有子元素的集合
			List node = root.getChildren();
			Element et = null;
			for (int i = 0; i < node.size(); i++) {
				et = (Element) node.get(i);// 循环依次得到子元素
				List subNode = et.getChildren(); // 得到内层子节点
				Map map = new HashMap();
				Element subEt = null;
				for (int j = 0; j < subNode.size(); j++) {
					subEt = (Element) subNode.get(j); // 循环依次得到子元素
					map.put(subEt.getName(), subEt.getText()); // 装入到Map中
				}
				
				// Map获取到值时才装入
				if (map.size() > 0)
					result.add(map);
			}
		} catch (JDOMException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		return result;
	}

	/**
	 * 解析xml字符串成Map
	 * 
	 * @param
	 * @return List
	 */
public static Map parseForMap(String xmlDoc) throws Exception {
		Map map = new HashMap();

		try{
		// 创建一个新的字符串
		StringReader xmlString = new StringReader(xmlDoc);
		// 创建新的输入源SAX 解析器将使用 InputSource 对象来确定如何读取 XML 输入
		InputSource source = new InputSource(xmlString);
		// 创建一个新的SAXBuilder
		SAXBuilder saxb = new SAXBuilder();

		List result = null;
		result = new ArrayList();
		// 通过输入源构造一个Document
		Document doc = saxb.build(source);
		// 取的根元素
		Element root = doc.getRootElement();
		List node = root.getChildren();
		// 得到根元素所有子元素的集合
		Element et = null;
		for (int i = 0; i < node.size(); i++) {
			et = (Element) node.get(i); // 循环依次得到子元素
			if (et.getChildren() != null && et.getChildren().size() > 0){					
				List<Map> details= new ArrayList<Map>();
				for (int j = 0 ; j < et.getChildren().size() ; j++){
					Element dt = (Element)et.getChildren().get(j);	
					if (dt.getChildren() != null && dt.getChildren().size() >0){
						Map<String ,Object> deMap = new HashMap<String,Object>();
						for (int z = 0 ; z < dt.getChildren().size(); z++){
							Element le = (Element)dt.getChildren().get(z);
							deMap.put(le.getName(), le.getText());
						}
						details.add(deMap);
					}					
				}
				map.put("details", details);
			}else{
				map.put(et.getName(), et.getText()); // 装入到Map中
			}
		}
		}catch(Exception e){
			logger.error("parseForMap===error===="+e);
			throw new Exception(e);
		}	
		return map;
	}

2.金额转大写

package com.cmrh.atp.util;

import org.apache.commons.lang.StringUtils;

import java.math.BigDecimal;
import java.math.BigInteger;
/**
 * 将金额转换成大写金额
 * @author ex-zhouyf001
 *
 */
public class NumberUtil {
	 //阿拉伯数字对应大写中文数字
    private final static String[] CN_NUMERALS = {"零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"};
    //低单位
    private final static String[] CN_NUM_UNIT = {"", "拾", "佰", "仟"};
    //万元以上高单位
    private final static String[] CN_NUM_HIGHT_UNIT = {"", "万", "亿", "万亿"};
    //小数位单位
    private final static String[] CN_NUM_DECIMAL_UNIT = {"", "角", "分"};
    
  
    /**
     * 转换成中文大写金额（最高支持万亿和两位小数）
     * @param num
     * @return
     */
    public static String toUppercase(Double num){
        return toUppercase(String.valueOf(num));
    }

    /**
     * 转换成中文大写金额（最高支持万亿和两位小数）
     * @param num
     * @return
     */
    public static String toUppercase(String num){
        String[] strNumArray = num.split("\\.");
        int strNumArrayLength = strNumArray.length;
        if(strNumArrayLength > 2 || (strNumArrayLength == 2 && strNumArray[1].length() > 2)){
           System.out.println("金额格式异常，不能有多个小数点，小数位最多只能两位！");
        }
        BigDecimal bigDecimal = new BigDecimal(strNumArray[0]);
        BigInteger bigInteger = bigDecimal.toBigInteger();

        char[] chars = bigInteger.toString().toCharArray();
        int intLength = chars.length;

        StringBuilder strBuilder = new StringBuilder();
        for(int i=0; i<intLength; i++){
            String curCnNum = CN_NUMERALS[charNumToInt(chars[i])];
            int ui = ((intLength-1)-i)%4;
            int hui = ((intLength-1)-i)/4;
            strBuilder.append(curCnNum);
            if(!isZero(curCnNum)){
                strBuilder.append(CN_NUM_UNIT[ui]);
                String heightUnit = CN_NUM_HIGHT_UNIT[hui];
                //如果剩余没有低金额单位或者后续都为零则加上高单位
                if(ui == 0 || isZeroInResidue(chars, i, ui)){
                    strBuilder.append(heightUnit);
                    //万单位以后的千单位如果不能为零则跳过零
                    if(heightUnit.equals(CN_NUM_HIGHT_UNIT[1]) && !isZeroOfIndex(chars, (ui+1)+i)){
                        i = i+skipZero(chars, i);
                    }
                }
            }
        }
        clearZero(0, strBuilder);
        //小数位转换
        strBuilder.append("圆");
        if(strNumArrayLength == 1 || strNumArray[1].matches("^[0]*$")){
            strBuilder.append("整");
            return strBuilder.toString();
        }
        char[] decimalChars = strNumArray[1].toCharArray();
        int decimalCharLength = decimalChars.length;
        for(int i=1; i<=decimalCharLength; i++){
            String cnNum = CN_NUMERALS[charNumToInt(decimalChars[i-1])];
            if(!isZero(cnNum)){
                strBuilder.append(cnNum).append(CN_NUM_DECIMAL_UNIT[i]);
            }else if(i == decimalCharLength){
                if(strBuilder.toString().startsWith("圆")){
                    return strBuilder.toString().substring(1);
                }
                return strBuilder.toString();
            }else{
                strBuilder.append(cnNum);
            }
        }
        if(strBuilder.toString().startsWith("圆零")){
            return strBuilder.toString().substring(2);
        }
        return strBuilder.toString();
    }




    /**
     * 递归清除多余的零
     * @param startIndex
     * @param strBuilder
     */
    private static void clearZero(int startIndex, StringBuilder strBuilder){
        int strLength = strBuilder.length();
        int zeroIndex = strBuilder.indexOf(CN_NUMERALS[0], startIndex);
        if(zeroIndex <= -1){
            return;
        }
        if(strLength <= zeroIndex+1){
            strBuilder.deleteCharAt(zeroIndex);
            return;
        }
        if(zeroIndex > -1 && isZero(strBuilder.charAt(zeroIndex+1))){
            strBuilder.deleteCharAt(zeroIndex);
            clearZero(startIndex, strBuilder);
            return;
        }
        if(strLength > zeroIndex+1){
            clearZero(zeroIndex+1, strBuilder);
            return;
        }
    }

    private static boolean isZero(String cnNum){
        return cnNum.equals(CN_NUMERALS[0]);
    }

    private static boolean isZero(char cnNum){
        return isZero(String.valueOf(cnNum));
    }

    /**
     * 跳过为零的下标
     * @param chars
     * @param beginIndex
     * @return
     */
    private static int skipZero(char[] chars, int beginIndex){
        int newIndex = 0;
        int charLength = chars.length;
        for(int i=beginIndex+1; i<charLength; i++){
            if(isZero(CN_NUMERALS[charNumToInt(chars[i])])){
                newIndex++;
            }else{
                break;
            }
        }
        return newIndex;
    }

    /**
     * 指定下标值是否是为零
     * @param chars
     * @param index
     * @return boolean
     */
    private static boolean isZeroOfIndex(char[] chars, int index){
        int numInex = Integer.parseInt(String.valueOf(chars[index]), 10);
        String cnNum = CN_NUMERALS[numInex];
        return isZero(cnNum);
    }

    /**
     * 从begin开始至end结束是否都是零
     * @param chars
     * @param begin
     * @param end
     * @return
     */
    private static boolean isZeroInResidue(char[] chars, int begin, int end){
        for(int i=1; i<=end; i++){
            boolean r = isZeroOfIndex(chars, begin+i);
            if(!r){
                return false;
            }
        }
        return true;
    }

    /**
     * char类型数值转换为int
     * @param charNum
     * @return
     */
    private static int charNumToInt(char charNum){
        String ns = String.valueOf(charNum);
        return Integer.parseInt(ns, 10);
    }

    /**
     * 字符串+1
     * @param str
     */
    public static String addOne(String str){
        String[] strs = str.split("[^0-9]");
        String numStr = strs[strs.length-1];
        if(numStr != null && numStr.length()>0){
            int n = numStr.length();
            int num = Integer.parseInt(numStr)+1;
            String added = String.valueOf(num);
            n = Math.min(n, added.length());
            //拼接字符串
            return str.subSequence(0, str.length()-n)+added;
        }else{
            throw new NumberFormatException();
        }
    }
}

标题