数据格式化工具

统一数据格式化转换

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

 

本工具类依赖 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 Jinput
* @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){
        checkArgument(data.getValue() instanceof Number, "常规格式转换错误,非数值类型");
        String value = data.getValue().toString();
        int decimalPointDigits = data.getDigits();
        if(decimalPointDigits > 0){
            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){
        checkArgument(data.getValue() instanceof Number, "数值格式转换错误,非数值类型");
        String value = data.getValue().toString();
        int decimalPointDigits = data.getDigits();
        if(decimalPointDigits > 0){
            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){
        checkArgument(data.getValue() instanceof Number, "百分比格式转换错误,非数值类型");
        String value = data.getValue().toString();
        int decimalPointDigits = data.getDigits();
        if(decimalPointDigits > 0){
            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){
        checkArgument(data.getValue() instanceof Number, "货币格式转换错误,非数值类型");
        return currency_china.getSymbol()+thousandsSeparated(data);
    }
 
    // 千位分隔
    private static String thousandsSeparated(FieldFormatModel data){
        checkArgument(data.getValue() instanceof Number, "千位分隔格式转换错误,非数值类型");
        String value = data.getValue().toString();
        int decimalPointDigits = data.getDigits();
        if(decimalPointDigits > 0){
            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){
        checkArgument(data.getValue() instanceof Number, "千位计数格式转换错误,非数值类型");
        String value = data.getValue().toString();
        double v = Double.parseDouble(value) / 1000;
        value = String.valueOf(v);
        int decimalPointDigits = data.getDigits();
        if(decimalPointDigits > 0){
            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("yyyy/MM/dd");
    }
 
    // 长日期格式化转换
    private static String longDate(FieldFormatModel data){
        DateTime dateTime = buildDateTime(data.getValue());
        return dateTime.toString("yyyy/MM/dd EE");
    }
 
 
    // 格式化模板统一转换
    private static StringBuilder buildBuilder(String satrtChars, int n, Character c){
        StringBuilder builder = new StringBuilder(satrtChars);
        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);
}