converter.java~3~

demo for java

  Yi = Long.parseLong(getInt(Y)); //Y的整数部分
  Yf = Long.parseLong(getFloat(Y)); //Y的小数部分
  Yp = getFloat(Y).length(); //Y小数部分的位数

  //处理同位运算
  tmp = "1";
  if (Xp > Yp) { //例：X=10.232 Y=12.8

    for (int I = 0; I < (Xp - Yp); I++) {
      tmp += "0";
      //生成进位值 如上例 X有3位小数，Y有1位小数，3-1=2 循环2次生成进位值"1"+"0"+"0" ="100"
    }

    Yf = Yf * Long.parseLong(tmp); //如上例 Y的小数8*进位值100=800 这样小数位的运算就变成了232和800
    Yp = Xp; //同步小数位
  }

  if (Xp < Yp) { //例：X=10.2 Y=12.83

    for (int I = 0; I < (Yp - Xp); I++) {
      tmp += "0";
      //生成进位值 如上例 X有1位小数，Y有2位小数，2-1=1 循环1次生成进位值"1"+"0" ="10"
    }

    Xf = Xf * Long.parseLong(tmp); //如上例 X的小数2*进位值10=20 这样小数位的运算就变成了20和83
    Xp = Yp; //同步小数位
  }

  Ri = Xi + Yi; //X、Y整数部分相加
  Rf = Xf + Yf; //X、Y小数部分相加

  tmp = String.valueOf(Rf); //获取分开运算后的小数值

  if (tmp.length() < Xp) { //位数不够前面补"0"
    for (int I = tmp.length(); I < Xp; I++) {
      tmp = "0" + tmp;
    }
    return FormatFloat(Ri + "." + tmp, 2); //返回运算结果
  }

  if (tmp.length() > Xp) { //运算后小数位长度大于原长度要处理进位问题

    a = tmp.substring(0, 1); //提取进位数
    b = tmp.substring(1, Xp + 1); //提取小数部分

    Ri += Byte.parseByte(a); //将原X、Y整数部分运算后的结果加上刚提取出来的进位数

    return FormatFloat(Ri + "." + b, 2); //返回运算结果

  }
  else {
    return FormatFloat(Ri + "." + Rf, 2); //直接返回运算结果
  }

}

  public static String Subtract(String X, String Y) {

    //浮点数减法运算
    //处理步骤:
    //	1.将浮点数的整数部分和小数部分分离出来
    //	2.让小数位同位
    //	3.整数部分运算
    //	4.处理小数位借位
    //	5.小数部分运算
    //	6.返回运算结果。

    long Xi, Xf; //X的整数部分Xi，X的小数部分Xf
    long Yi, Yf; //X的整数部分Yi，X的小数部分Yf
    long Ri, Rf; //Ri存放整数部分的运算结果，Rf存放小数部分的运算结果
    int Xp, Yp; //Xp,Yp用于处理小数位长度
    String Sign = ""; //用算负数标志
    String tmp; //用于小数位同位计算

    if (XbigmoreY(X, Y) == 0) { //如果X小于Y则对它们进行数值互换
      tmp = X;
      X = Y;
      Y = tmp;
      Sign = "-"; //并且添加负数标志
    }

    Xi = Long.parseLong(getInt(X)); //提取X的整数部分
    Xf = Long.parseLong(getFloat(X)); //提取X的小数部分
    Xp = getFloat(X).length(); //获取X小数部分的位数

    Yi = Long.parseLong(getInt(Y)); //提取Y的整数部分
    Yf = Long.parseLong(getFloat(Y)); //提取Y的小数部分
    Yp = getFloat(Y).length(); //获取Y小数部分的位数

    //处理同位运算
    tmp = "1";
    if (Xp > Yp) { //例：X=10.232 Y=12.8

      for (int I = 0; I < (Xp - Yp); I++) {
        tmp += "0";
        //生成进位值 如上例 X有3位小数，Y有1位小数，3-1=2 循环2次生成进位值"1"+"0"+"0" ="100"
      }

      Yf = Yf * Long.parseLong(tmp); //如上例 Y的小数8*进位值100=800 这样小数位的运算就变成了232和800
      Yp = Xp; //同步小数位
    }

    if (Xp < Yp) { //例：X=10.2 Y=12.83

      for (int I = 0; I < (Yp - Xp); I++) {
        tmp += "0";
        //生成进位值 如上例 X有1位小数，Y有2位小数，2-1=1 循环1次生成进位值"1"+"0" ="10"
      }

      Xf = Xf * Long.parseLong(tmp); //如上例 X的小数2*进位值10=20 这样小数位的运算就变成了20和83
      Xp = Yp; //同步小数位
    }

    Ri = Xi - Yi; //X、Y整数部分相减

    if (Xf < Yf) { //如果X的小数部分比Y的小数部分小则Xf借位
      tmp = "1";
      for (int I = 1; I < Xp; I++) {
        tmp += "0";
      }
      Xf += Long.parseLong(tmp += "0"); //加上进位值
      Ri -= 1; //整数部分相应减1
    }

    Rf = Xf - Yf; //X、Y小数部分相减

    tmp = String.valueOf(Rf);
    for (int I = tmp.length(); I < Xp; I++) { //如果长度不够在前面补足"0"
      tmp = "0" + tmp;
    }

    return Sign + FormatFloat(Ri + "." + tmp, 2); //返回运算结果

  }

  public static String Multiplication(String X, String Y) {

    //浮点数乘法运算
    //处理步骤:
    // 1.获取小数点位数
    // 2.将浮点数进位成整数
    // 3.进位后的整数运算
    // 4.处理小数位数
    // 5.返回运算结果

    int Xp, Yp; //Xp,Yp用于处理小数位长度
    String tmp, a, b; //临时存贮用变量

    a = getFloat(X); //X的小数部分
    b = getFloat(Y); //Y的小数部分

    if (Long.parseLong(a) == 0) {
      a = "";
    }
    if (Long.parseLong(b) == 0) {
      b = "";

    }
    Xp = a.length(); //获取X小数部分的位数
    Yp = b.length(); //获取Y小数部分的位数

    X = getInt(X) + a; //进位成整数
    Y = getInt(Y) + b; //进位成整数

    tmp = String.valueOf( (Long.parseLong(X) * Long.parseLong(Y))); //进位后的运算结果

    for (int I = tmp.length(); I < (Xp + Yp); I++) { //如果长度不够在前面补足"0"
      tmp = "0" + tmp;
    }

    a = tmp.substring(0, tmp.length() - (Xp + Yp)); //结果整数部分
    b = tmp.substring(tmp.length() - (Xp + Yp), tmp.length()); //结果小数部分

    if (a.length() == 0) {
      a = "0"; //整数部分为空等于0

    }
    return FormatFloat(a + "." + b, 2); //返回运算结果

  }

  public static String Division(String X, String Y) {

    //浮点数除法运算
    //处理步骤:
    // 1.获取小数点位数
    // 2.将浮点数进位成整数
    // 3.直除取得商值(整数部分)
    // 4.反复进行商、余运算直到除尽或达到最大精确位(小数部分)
    // 5.返回运算结果

    long Xf, Yf; //Xi存放X的小数部分，Xf存放Y的小数部分
    long Xt, Yt; //临时绝对值后的X和Y
    long Quotient, Remainder, Result; //Quotient商、Remainder余、结果Result
    int Xp, Yp; //Xp,Yp用于处理小数位长度
    String tmp, a, b; //临时存贮用变量

    a = getFloat(X); //X的小数部分
    b = getFloat(Y); //Y的小数部分

    if (Long.parseLong(a) == 0) {
      a = "";
    }
    if (Long.parseLong(b) == 0) {
      b = "";

    }
    Xp = a.length(); //获取X小数部分的位数
    Yp = b.length(); //获取Y小数部分的位数

    X = getInt(X) + a; //进位成整数
    Y = getInt(Y) + b; //进位成整数

    //处理同位运算
    tmp = "1";
    if (Xp > Yp) { //例：X=10.232 Y=12.8

      for (int I = 0; I < (Xp - Yp); I++) {
        tmp += "0";
        //生成进位值 如上例 X有3位小数，Y有1位小数，3-1=2 循环2次生成进位值"1"+"0"+"0" ="100"
      }

      Y = "" + Long.parseLong(Y) * Long.parseLong(tmp); //如上例 Y的小数8*进位值100=800 运算就变成了10232和12800
      Yp = Xp; //同步小数位

    }

    if (Xp < Yp) { //例：X=10.2 Y=12.83

      for (int I = 0; I < (Yp - Xp); I++) {
        tmp += "0";
        //生成进位值 如上例 X有1位小数，Y有2位小数，2-1=1 循环1次生成进位值"1"+"0" ="10"
      }

      X = "" + Long.parseLong(X) * Long.parseLong(tmp); //如上例 X的小数2*进位值10=20 这样运算就变成了1020和1283
      Xp = Yp; //同步小数位
    }

    Xt = Long.parseLong(X); //临时将X移到Xt上
    Yt = Long.parseLong(Y); //临时将Y移到Yt上
    if (Xt < 0) {
      Xt *= -1; //保证Xt为正数
    }
    if (Yt < 0) {
      Yt *= -1; //保证Yt为正数

    }
    tmp = "";
    Remainder = Xt;

    for (int I = 0; I < 16; I++) { //反复进行商、余运算直到除尽或达到最大精确位
      Quotient = Remainder / Yt; //求商
      Remainder = Remainder - (Quotient * Yt); //求余
      if (Remainder == 0) {
        break; //如果余等于0表示除尽则跳出运算
      }
      Remainder *= 10; //进位
      Result = Remainder / Yt; //单次运算结果
      tmp += Result; //累加结果
    }

    if (tmp == "") {
      tmp = "0";

    }
    return FormatFloat(Long.parseLong(X) / Long.parseLong(Y) + "." + tmp, 2); //返回运算结果

  }

  static String getInt(String I) { //提取浮点数整数部分

    int point; //point变量存贮小数点在浮点数中的位置
    point = I.indexOf("."); //捕捉小数点位置

    if (point == 0) {
      return "0"; //"."在第1位直接返回0
    }

    if (point < 0) { //（找不到"."point值为-1)
      return I; //如果没有小数点则直接返回整数
    }
    else {
      return I.substring(0, point); //找到就返回小数点前段部分
    }

  }

  static String getFloat(String I) { //提取浮点数小数部分

    int point; //point变量存贮小数点在浮点数中的位置
    point = I.indexOf("."); //捕捉小数点位置

    if (point < 0 || point == (I.length() - 1)) {
      return "0"; //找不到"."或"."在最后1位直接返回0
    }
    else {
      point += 1; //在"."位置上向后移一位是为了方便将小数部分提取出来
      return I.substring(point, I.length()); //找到就返回小数点后段部分
    }

  }

  static int XbigmoreY(String X, String Y) { //浮点数比较X是否大于Y

    long Xi, Xf; //X的整数部分Xi，X的小数部分Xf
    long Yi, Yf; //Yi存放Y的整数部分，Yf存放Y的小数部分
    int Xp, Yp; //Xp、Yp用于处理小数位长度
    String tmp; //临时变量

    Xi = Long.parseLong(getInt(X)); //提取X的整数部分
    Xf = Long.parseLong(getFloat(X)); //提取X的小数部分
    Xp = getFloat(X).length(); //获取X小数部分的位数

    Yi = Long.parseLong(getInt(Y)); //提取Y的整数部分
    Yf = Long.parseLong(getFloat(Y)); //提取Y的小数部分
    Yp = getFloat(Y).length(); //获取Y小数部分的位数

    //处理同位运算
    tmp = "1";
    if (Xp > Yp) { //例：X=10.232 Y=12.8

      for (int I = 0; I < (Xp - Yp); I++) {
        tmp += "0";
        //生成进位值 如上例 X有3位小数，Y有1位小数，3-1=2 循环2次生成进位值"1"+"0"+"0" ="100"
      }

      Yf = Yf * Long.parseLong(tmp); //如上例 Y的小数8*进位值100=800 这样小数位的运算就变成了232和800
      Yp = Xp; //同步小数位
    }

    if (Xp < Yp) { //例：X=10.2 Y=12.83

      for (int I = 0; I < (Yp - Xp); I++) {
        tmp += "0";
        //生成进位值 如上例 X有1位小数，Y有2位小数，2-1=1 循环1次生成进位值"1"+"0" ="10"
      }

      Xf = Xf * Long.parseLong(tmp); //如上例 X的小数2*进位值10=20 这样小数位的运算就变成了20和83
      Xp = Yp; //同步小数位
    }

    if ( (Xi == Yi) && (Xf == Yf)) {
      return 2; //如果X=Y返回2
    }

    if ( (Xi > Yi) || ( (Xi == Yi) && (Xf > Yf))) {
      return 1; //X大Y返回1
    }
    else {
      return 0; //否则返回0
    }
  }

  static String FormatFloat(String X, int length) { //用来处运算结果小数部分多余的0

    String Xi, Xf, tmp; //整数部分Xi,小数部分Xf,临时变量tmp

    Xi = getInt(X); //X的整数部分
    Xf = getFloat(X); //X的小数部分

    if (Xf.length() > length) {
      Xf = Xf.substring(0, length);
    }
    int Xl = Xf.length(); //小数部分长度

    for (int I = 1; I < Xl; I++) {
      tmp = Xf.substring(Xf.length() - 1, Xf.length()); //提取最尾数

      if (Byte.parseByte(tmp) == 0) {
        Xf = Xf.substring(0, Xf.length() - 1); //如果最尾数是0就剔除
      }
      else {
        break; //否则跳出
      }
    }

    if (Long.parseLong(Xf) == 0) {
      tmp = ""; //如果X的小数部分等于0就剔除小数点
    }
    else {
      tmp = "." + Xf; //否则保持原样
    }

    return Xi + tmp; //返回处理结果
  }

}