金融记数法 普通数字 相互转换

import java.beans.BeanInfo;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.text.DecimalFormat;
import java.text.NumberFormat;

public class OlogyCount {
    /**
     * 金融记数法转换成普通数字型。
     * <br>例如 132,000,123.00 转换后为 132000123.00
     * @param data - 要转换的数字字符串
     * @return String - 返回转换后的数字字符串
     */
    public static String finalToNormal(String data) {
        if(data.trim()==null||data.trim().equals(""))return "";
        //String newData = data.replaceAll(",", ""); //since jdk 1.4
        String newData = data;
        int index = newData.indexOf(‘,‘);
        while(index != -1){
            newData = newData.substring(0, index) + newData.substring(index+1);
            index = newData.indexOf(‘,‘);
        }

        /*
        int pos = newData.lastIndexOf(‘.‘);
        int len = 0; //小数位数
        if (pos != -1) {
            len = newData.length() - 1 - pos;
        }

        try {
            double d = Double.parseDouble(newData);
            NumberFormat form = NumberFormat.getInstance();
            String mask = "###0";
            if (len > 0) {
                mask = "###0.";
                for (int i = 0; i < len; i++) {
                    mask = mask + "0";
                }
            }
            ((DecimalFormat) form).applyPattern(mask);
            newData = form.format(d);
        } catch (Exception e) {
            e.printStackTrace();
        }
        */
        return newData;
    }

    /**
     * 普通数字型转换成金融记数法。
     * <br>例如 132000123.00 转换后为 132,000,123.00
     * @param data - 要转换的数字字符串
     * @return String - 返回转换后的数字字符串
     */
    public static String normalToFinal(String data) {
        if(data.trim()==null||data.trim().equals(""))return "";
        int pos = data.lastIndexOf(‘.‘);
        int len = 0; //小数位数
        if (pos != -1) {
            len = data.length() - 1 - pos;
        }

        try {
            double d = Double.parseDouble(data);
            NumberFormat form = NumberFormat.getInstance();
            String mask = "#,##0";
            if (len > 0) {
                mask = "#,##0.";
                for (int i = 0; i < len; i++) {
                    mask = mask + "0";
                }
            }

            ((DecimalFormat) form).applyPattern(mask);
            return form.format(d);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 普通数字型转换成金融记数法。
     * <br>例如 132000123.00 转换后为 132,000,123.00
     * <br>小数点保留两位
     * @param data - 要转换的数字
     * @return String - 返回转换后的数字字符串
     */
    public static String normalToFinal(double data) {
        try {
            NumberFormat form = NumberFormat.getInstance();
            String mask = "#,##0.00";
            ((DecimalFormat) form).applyPattern(mask);
            return form.format(data);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    /**
         * Bean 中普通数字型转换成金融记数法。
         * <br>小数点保留两位
         * @param obj - 要转换的对象
         * @param obj - 不要转换的属性集合
         * @return String - 返回转换后的数字字符串对象
         */
    public static Object beanToNoFinal(Object obj,String jH[]) throws Exception{
            Class type = obj.getClass();
            boolean flag=false;
            try{
//*********获得BEAN 的BEAN信息
                BeanInfo info = Introspector.getBeanInfo(type);
//*********通过BEAN的信息获得性质特制集合
                PropertyDescriptor[] props = info.getPropertyDescriptors();
//*********循环传递数据
                for (int i = 0; i < props.length; i++) {
                    flag=false;
//*********获得第1个BEAN的每个属性名与GET方法
                    String name = props[i].getName();
                    Method getMethod = props[i].getReadMethod();
//**********如果获得的属性名是jH含有的属性名 把标志设置为真！
                    for(int s=0;s<jH.length;s++){
                        if(name.equals(jH[s].toString())||"class".equals(name)
                        ||"multipartRequestHandler".equals(name)||"servlet".equals(name)
                        ||"servletWrapper".equals(name))flag=true;
                    }
                    if(!flag){

//*********获得第BEAN的 SET方法
                            Method setMethod = props[i].getWriteMethod();
                            if(getMethod.invoke(obj,null)==null)setMethod.invoke(obj,new Object[]{"0"});
                            setMethod.invoke(obj,new Object[]{OlogyCount.normalToFinal(Double.valueOf(getMethod.invoke(obj,null).toString()).doubleValue())});
                        }
                }
            }catch(Exception e){
                throw new Exception("获得对象转换科学计算法出错！");
            }
            return obj;
    }
    /**
         * 金融记数法换成普通数字型转。
         * <br>小数点保留两位
         * @param obj - 要转换的对象
         * @param obj - 不要转换的属性集合
         * @return String - 返回转换后的数字字符串对象
         */
    public static Object beanGetNoFinal(Object obj,String jH[]) throws Exception{
            Class type = obj.getClass();
            boolean flag=false;
            try{
//*********获得BEAN 的BEAN信息
                BeanInfo info = Introspector.getBeanInfo(type);
//*********通过BEAN的信息获得性质特制集合
                PropertyDescriptor[] props = info.getPropertyDescriptors();
//*********循环传递数据
                for (int i = 0; i < props.length; i++) {
                    flag=false;
//*********获得第1个BEAN的每个属性名与GET方法
                    String name = props[i].getName();
                    Method getMethod = props[i].getReadMethod();
//**********如果获得的属性名是jH含有的属性名 把标志设置为真！
                    for(int s=0;s<jH.length;s++){
                        if(name.equals(jH[s].toString())||"class".equals(name)
                        ||"multipartRequestHandler".equals(name)||"servlet".equals(name)
                        ||"servletWrapper".equals(name))flag=true;
                    }
                    if(!flag){

//*********获得第BEAN的 SET方法
                            Method setMethod = props[i].getWriteMethod();
                            if(getMethod.invoke(obj,null)==null)setMethod.invoke(obj,new Object[]{"0"});
                            setMethod.invoke(obj,new Object[]{new String(OlogyCount.finalToNormal(getMethod.invoke(obj,null).toString().trim()))});
                        }
                }
            }catch(Exception e){
                throw new Exception("获得对象科学计算法转换数字出错！");
            }
            return obj;
    }
    /**
         * Bean 中普通数字型转换成金融记数法。
         * <br>小数点保留两位
         * @param obj - 要转换的对象
         * @param obj - 要转换的属性集合
         * @return String - 返回转换后的数字字符串对象
         */
    public static Object beanToFinal(Object obj,String jH[]) throws Exception{
            Class type = obj.getClass();
            boolean flag=false;
            try{
//*********获得BEAN 的BEAN信息
                BeanInfo info = Introspector.getBeanInfo(type);
//*********通过BEAN的信息获得性质特制集合
                PropertyDescriptor[] props = info.getPropertyDescriptors();
//*********循环传递数据
                for (int i = 0; i < props.length; i++) {
                    flag=false;
//*********获得第1个BEAN的每个属性名与GET方法
                    String name = props[i].getName();
                    Method getMethod = props[i].getReadMethod();
//**********如果获得的属性名是jH含有的属性名 把标志设置为真！
                    for(int s=0;s<jH.length;s++){
                        if(name.equals(jH[s].toString())&&!"class".equals(name)
                        &&!"multipartRequestHandler".equals(name)&&!"servlet".equals(name)
                        &&!"servletWrapper".equals(name))flag=true;
                    }
                    //
                    if(flag){
//*********获得第BEAN的 SET方法
                            Method setMethod = props[i].getWriteMethod();
                            if(getMethod.invoke(obj,null)==null)setMethod.invoke(obj,new Object[]{"0"});
                            setMethod.invoke(obj,new Object[]{OlogyCount.normalToFinal(Double.valueOf(getMethod.invoke(obj,null).toString()).doubleValue())});
                            //System.out.println(name+"---"+getMethod.invoke(obj,null).toString());
                        }
                }
            }catch(Exception e){
                throw new Exception("获得对象转换科学计算法出错！");
            }
            return obj;
    }
    /**
         * 金融记数法换成普通数字型转。
         * <br>小数点保留两位
         * @param obj - 要转换的对象
         * @param obj - 要转换的属性集合
         * @return String - 返回转换后的数字字符串对象
         */
    public static Object beanGetFinal(Object obj,String jH[]) throws Exception{
            Class type = obj.getClass();
            boolean flag=false;
            String name="";
            Method getMethod=null;
            try{
//*********获得BEAN 的BEAN信息
                BeanInfo info = Introspector.getBeanInfo(type);
//*********通过BEAN的信息获得性质特制集合
                PropertyDescriptor[] props = info.getPropertyDescriptors();
//*********循环传递数据
                for (int i = 0; i < props.length; i++) {
                    flag=false;
//*********获得第1个BEAN的每个属性名与GET方法
                    name = props[i].getName();
                    getMethod = props[i].getReadMethod();
//**********如果获得的属性名是jH含有的属性名 把标志设置为真！
                    System.out.println(name);
                    for(int s=0;s<jH.length;s++){
                        if(name.equals(jH[s].toString())&&!"class".equals(name)
                        &&!"multipartRequestHandler".equals(name)&&!"servlet".equals(name)
                        &&!"servletWrapper".equals(name))flag=true;
                    }
                    if(flag){
//*********获得第BEAN的 SET方法
                            Method setMethod = props[i].getWriteMethod();
                            if(getMethod.invoke(obj,null)==null)setMethod.invoke(obj,new Object[]{"0"});
                            if(Double.valueOf(getMethod.invoke(obj,null).toString()).doubleValue()!=new Double("0").doubleValue())
                            setMethod.invoke(obj,new Object[]{new String(OlogyCount.finalToNormal(getMethod.invoke(obj,null).toString().trim()))});
                        }

                }
            }catch(Exception e){
                try {
                    System.out.println(e+e.getMessage()+name+getMethod.invoke(obj,null).toString());
                } catch (IllegalArgumentException e1) {
                    // TODO 自动生成 catch 块
                    e1.printStackTrace();
                } catch (IllegalAccessException e1) {
                    // TODO 自动生成 catch 块
                    e1.printStackTrace();
                } catch (InvocationTargetException e1) {
                    // TODO 自动生成 catch 块
                    e1.printStackTrace();
                }
                throw new Exception("获得对象科学计算法转换数字出错！");
            }
            return obj;
    }

}
时间： 2024-09-29 09:30:23

金融记数法 普通数字 相互转换的相关文章

Swift入门（九）——String与Int、Double、Float等数字相互转换

三种转换模式 任何语言里面,Int.float.double等数字类型自成一派,但它们和String类型之间的转换总是不太方便,这里总结一下它们相互转换的方法.总结下来一共有三种转换模式,分别举例说明. 一.String转数字 这里以String类型转Int类型为例.String转其他的数字类型(Float.Double等)大同小异.主要用到的方法是String类型的toInt方法.注意这个方法返回的是Int?,即一个整数可选类型.所以需要解封. var string = "1234"

php实现IP地址和数字相互转换

echo $a=ip2long ("202.97.224.68");//地址转换成数字 系统自带的函数 注:这里面有一个要注意的地方,大概由于PHP无法正确判断转换完的数字类型,出现负数的情况. 这时候只要把原来IP对应的字段int转换成bigint即可 echo 'trueip:'.long2ip('3793747831');//数字转换成IP地址 系统自带的函数

vb 字符串和数字相互转换函数

VB中的字符串函数比较多,也比较方便,就不一一介绍了.本文主要对字符串相关的转换函数做一些小结.字符串转换的函数主要有: Str()和Val()用于字符串和数字的相互转换; Chr()和Asc()用于字符串和AscII码的相互转换; Chrw()和Ascw()用于Unicode码和中文的相互转换; Format()函数用途十分广泛的一个函数,功能十分强大. 在这些函数中前两对和Format()函数是我们经常用到的,这里只给出前两对的几个简单例子: (1) MyString = Str(-459.

C/C++ 字符串与数字相互转换

一.利用stringstream类 1. 字符串到整数 stringstream sstr(str); int x; sstr >> x;(即从sstr中提取数据)2. 整数到字符串 stringstream sstr; int x; sstr << x; string str = sstr.str(); 缺点:处理大量数据转换速度较慢.stringstream不会主动释放内存,如果要在程序中用同一个流,需要适时地清除一下缓存(用stream.str("")和s

C标准中的字符串-数字相互转换

数字转为字符串: 在C标准库中与平台无关的转换只有int sprintf( char *buffer, const char *format, [ argument] - );位于头文件stdio.h中. #include<stdio.h> int main(){ int num = 8; char numstr[128]; sprintf(numstr, "%d", num); printf(numstr); return 0; } 字符串转化为数字: 在C标准库中与平台

带小数的十进制数字和2进制数字相互转换的逻辑

不同进制是指不同位置上数字对应的权值不同. 2进制对应的权值是以2为底的指数20,21....等 1001001转换为十进制的话是1+8+64=73 从10进制向2进制转换: 整数部分"除2取余",小数部分"乘2取余" 乘二取整是针对十进制小数部分转换为二进制的方法,而整数部分为除二取余,具体如下: 将整数部分辗转相除2,将余数倒序排列,即整数部分的二进制数 将小数部分辗转相乘2,将乘积的个位数部分正序排列,即小数部分的二进制数 例: 将32.12转换为二进制数 整

C/C++中字符串与数字相互转换

sprintf int sprintf( char *buffer, const char *format, [ argument] … ); buffer:char型指针,指向将要写入的字符串的缓冲区. format:格式化字符串. [argument]...:可选参数,可以是任何类型的数据. 把某个格式化的数据写入字符缓冲区中 sscanf int sscanf(const char *buffer,const char *format,[argument ]...); buffer:存储的

数字转IP地址函数

--------------------------------------------------------------------- -- Author : htl258(Tony) -- Date   : 2010-06-19 10:34:31 -- Version: Microsoft SQL Server 2008 (RTM) - 10.0.1600.22 (Intel X86) --          Jul  9 2008 14:43:34 --          Copyrig

JavaScript中数字与字符串相互转化

一.数字转换成字符串 ①Number类定义的toString()方法:这个方法可以接收表示转换基数(radix,范围在2~36之间)的可选参数,如果不指定此参数,转换规则将是基于十进制.例如: ②Number类定义的toFixed()方法:这个方法可以指定小数点后的位数.例如: ③Number类定义的toExponential()方法:这个方法使用指数记数法将数字转换为指数形式的字符串,其中小数点前只有一位,小数点后的位数则由参数指定.例如: ④Number类定义的toPrecision()方法