数据格式化工具

统一数据格式化转换

支持类型 ： 常规类型，数值类型，百分比，货币，千分位，日期格式转换

 

本工具类依赖 guava ,lombox和 joda

Maven 引入相应jar包

 

<!--lombok-->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.16.14</version>
</dependency>
 
<!--joda-->
<dependency>
    <groupId>joda-time</groupId>
    <artifactId>joda-time</artifactId>
    <version>2.9.9</version>
</dependency>
 
<!--guava-->
<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>23.0</version>
</dependency>

 

 

package com.input4hua.xxx.utils;


import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.util.Currency;
import java.util.Date;
import java.util.Locale;
import java.util.function.Function;
import com.input4hua.xxx.model.FieldFormatModel;
import org.joda.time.DateTime;
import org.joda.time.format.DateTimeFormat;
import org.joda.time.format.DateTimeFormatter;
import static com.google.common.base.Preconditions.checkArgument;

/**
 * 数据格式化工具.
 *
 * @author Jiahua.hu
 * @since 21 十二月 2017
 */
public class DataFormaterUtils {

    private final static Currency currency_china = Currency.getInstance(Locale.CHINA);

    @FunctionalInterface
    private interface FormatFun extends Function<FieldFormatModel, String> {
    }

    private enum FormatEnum{
        NORMAL(DataFormaterUtils::normal),
        NUMBER(DataFormaterUtils::number),
        PERCENTAGE(DataFormaterUtils::percentage),
        CURRENCY(DataFormaterUtils::currency),
        THOUSANDS_SEPARATED(DataFormaterUtils::thousandsSeparated),
        THOUSANDS_COUNT(DataFormaterUtils::thousandsCount),
        SHORT_DATE(DataFormaterUtils::shortDate),
        LONG_DATE(DataFormaterUtils::longDate);

        private final FormatFun formatFun;

        FormatEnum(FormatFun formatFun) {
            this.formatFun = formatFun;
        }

        public String format(FieldFormatModel data) {
            return formatFun.apply(data);
        }
    }


    /**
     * 格式转换器
     *
     * @param data
     * @return
     */
    public static String parse(FieldFormatModel data){
        String type = data.getType().toUpperCase();
        FormatEnum formatEnum = FormatEnum.valueOf(type);
        return formatEnum.format(data);
    }

//常规数字格式转换
private static String normal(FieldFormatModel data){
    preString2Number(data,"常规格式转换错误,非数值类型");
    String value = data.getValue().toString();
    int decimalPointDigits = data.getDigits();
    boolean hasDecimalPoint = value.contains(".");
    if(hasDecimalPoint){
        BigDecimal bigDecimal = new BigDecimal(value);
        StringBuilder pointPatternBuf = buildBuilder("###0.",decimalPointDigits,'#');
        DecimalFormat NORMAL = new DecimalFormat(pointPatternBuf.toString());
        NORMAL.setRoundingMode(RoundingMode.HALF_UP);
        value = NORMAL.format(bigDecimal.doubleValue());
    }
    return value;
}

//数值格式转换
private static String number(FieldFormatModel data){
    preString2Number(data,"数值格式转换错误,非数值类型");
    String value = data.getValue().toString();
    int decimalPointDigits = data.getDigits();
    BigDecimal bigDecimal = new BigDecimal(value);
    StringBuilder pointPatternBuf = buildBuilder("###0.",decimalPointDigits,'0');
    DecimalFormat decimalFormat = new DecimalFormat(pointPatternBuf.toString());
    decimalFormat.setRoundingMode(RoundingMode.HALF_UP);
    value = decimalFormat.format(bigDecimal.doubleValue());
    return value;
}


//百分比
private static String percentage(FieldFormatModel data){
    preString2Number(data,"百分比格式转换错误,非数值类型");
    String value = data.getValue().toString();
    int decimalPointDigits = data.getDigits();
    BigDecimal bigDecimal = new BigDecimal(value);
    StringBuilder pointPatternBuf = buildBuilder("0.",decimalPointDigits,'0');
    DecimalFormat decimalFormat = new DecimalFormat(pointPatternBuf.append("%").toString());
    decimalFormat.setRoundingMode(RoundingMode.HALF_UP);
    value = decimalFormat.format(bigDecimal.doubleValue());
    return value;
}

//货币
private static String currency(FieldFormatModel data){
    preString2Number(data,"货币格式转换错误,非数值类型");
    return currency_china.getSymbol()+thousandsSeparated(data);
}

//千位分隔
private static String thousandsSeparated(FieldFormatModel data){
    preString2Number(data,"千位分隔格式转换错误,非数值类型");
    String value = data.getValue().toString();
    int decimalPointDigits = data.getDigits();
    BigDecimal bigDecimal = new BigDecimal(value);
    StringBuilder pointPatternBuf = buildBuilder(",##0.",decimalPointDigits,'0');
    DecimalFormat decimalFormat = new DecimalFormat(pointPatternBuf.toString());
    decimalFormat.setRoundingMode(RoundingMode.HALF_UP);
    value = decimalFormat.format(bigDecimal.doubleValue());
    return value;
}

//千位计数
private static String thousandsCount(FieldFormatModel data){
    preString2Number(data,"千位计数格式转换错误,非数值类型");
    String value = data.getValue().toString();
    double v = Double.parseDouble(value) / 1000;
    value = String.valueOf(v);
    int decimalPointDigits = data.getDigits();
    BigDecimal bigDecimal = new BigDecimal(value);
    StringBuilder pointPatternBuf = buildBuilder("0.",decimalPointDigits,'0');
    DecimalFormat decimalFormat = new DecimalFormat(pointPatternBuf.append("K").toString());
    decimalFormat.setRoundingMode(RoundingMode.HALF_UP);
    value = decimalFormat.format(bigDecimal.doubleValue());
    return value;
}

//短日期格式化转换
private static String shortDate(FieldFormatModel data){
    DateTime dateTime = buildDateTime(data.getValue());
    return dateTime.toString(DateUtil.SHORT_DATE_PATTERN);
}

//长日期格式化转换
private static String longDate(FieldFormatModel data){
    DateTime dateTime = buildDateTime(data.getValue());
    return dateTime.toString(DateUtil.LONG_DATE_PATTERN);
}

//统一字符转Number预处理
private static void preString2Number(FieldFormatModel data, String errorMessage) {
    if(data.getValue() instanceof String){
        String value = (String) data.getValue();
        NumberFormat nf = NumberFormat.getInstance();
        try {
            Number number = nf.parse(value);
            data.setValue(number);
        }
        catch (ParseException e) {
            throw new RuntimeException(data.getType()+"数值格式预处理转换错误,非数值类型["+data.getValue()+"]");
        }
    }
    checkArgument(data.getValue() instanceof Number, errorMessage+"["+data.getValue()+"]");
}

//格式化模板统一转换
private static StringBuilder buildBuilder(String satrtChars, int n, Character c){
    StringBuilder builder = new StringBuilder(satrtChars);
    if(n <= 0){
        builder.deleteCharAt(builder.length()-1);
    }else{
        for(int i=0;i<n;i++) {
            builder.append(c);
        }
    }
    return builder;
}


// 日期格式统一转换
    private static DateTime buildDateTime(Object value) {
        DateTime dateTime = null;
        if(value instanceof Date){
            dateTime = new DateTime(value);
        }else{
            String valStr = value.toString();
            DateTimeFormatter format = null;
            if(valStr.contains("-")){
                if(valStr.contains(":")){
                    format = DateTimeFormat.forPattern("yyyy-MM-dd HH:mm:ss");
                }else{
                    format = DateTimeFormat.forPattern("yyyy-MM-dd");
                }
            }else if(valStr.contains("/")){
                if(valStr.contains(":")){
                    format = DateTimeFormat.forPattern("yyyy/MM/dd HH:mm:ss");
                }else{
                    format = DateTimeFormat.forPattern("yyyy/MM/dd");
                }
            }else{
                throw new RuntimeException("时间格式转换错误,暂不支持相应日期格式转换");
            }
            dateTime = DateTime.parse(valStr, format);
        }
        return dateTime;
    }

}

 

 

---

package com.input4hua.xxx.model;
 
import java.io.Serializable;
import lombok.Data;
 
/**
* 格式化model
*
* @author Jinput
* @since 21 十二月 2017
*/
@Data
public class FieldFormatModel implements Serializable {
 
    private static final long serialVersionUID = -7409395670956855205L;
 
    private String name;
 
    private Object value;
 
    private String type;
 
    private int digits;
}

 

---

Use case

public static void main(String[] args) {
    //常规
    FieldFormatModel data = new FieldFormatModel();
    data.setType("NORMAL");
    data.setValue(123.125);
    data.setDigits(4);
    String parse = DataFormaterUtils.parse(data);
    System.out.println(parse);
    //数值
    FieldFormatModel data = new FieldFormatModel();
    data.setType("NUMBER");
    data.setValue(123);
    data.setDigits(2);
    String parse = DataFormaterUtils.parse(data);
    System.out.println(parse);
    //日期
    FieldFormatModel data = new FieldFormatModel();
    data.setType("LONG_DATE");
    data.setValue(new Date());
    String parse = DataFormaterUtils.parse(data);
    System.out.println(parse);
    //百分比
    FieldFormatModel data = new FieldFormatModel();
    data.setType("PERCENTAGE");
    data.setValue(0.12345);
    data.setDigits(3);
    String parse = DataFormaterUtils.parse(data);
    System.out.println(parse);
    //货币
    FieldFormatModel data = new FieldFormatModel();
    data.setType("CURRENCY");
    data.setValue(123.45);
    data.setDigits(3);
    String parse = DataFormaterUtils.parse(data);
    System.out.println(parse);
    //千位分隔
    FieldFormatModel data = new FieldFormatModel();
    data.setType("THOUSANDS_SEPARATED");
    data.setValue(111111222.013);
    data.setDigits(3);
    String parse = DataFormaterUtils.parse(data);
    System.out.println(parse);
    //千位计数
    FieldFormatModel data = new FieldFormatModel();
    data.setType("THOUSANDS_COUNT");
    data.setValue(4567889.123);
    data.setDigits(2);
    String parse = DataFormaterUtils.parse(data);
    System.out.println(parse);
}