程式師世界 >> 編程語言 >> JAVA編程 >> 關於JAVA >> java年夜數乘法的簡略完成浮點數乘法運算

java年夜數乘法的簡略完成浮點數乘法運算

編輯：關於JAVA

java年夜數乘法的簡略完成浮點數乘法運算。本站提示廣大學習愛好者：（java年夜數乘法的簡略完成浮點數乘法運算）文章只能為提供參考，不一定能成為您想要的結果。以下是java年夜數乘法的簡略完成浮點數乘法運算正文

return，break，next 這幾個症結字的應用都觸及到跳出感化域的成績，而他們的分歧則在於分歧的症結字跳出去的目標感化域的分歧，由於有代碼塊則招致有一些處所須要非分特別留意。
return
經常使用方法

平日情形下的return語句和年夜家懂得的意思是雷同的。

def m1 param
 if param == 1
  return 'returned 1'
 end
 'returned default value' # 依據Ruby說話標准，最初一條履行語句的成果將作為前往值前往，return是可選的
end

m1(1) # => returned 1
m1(2) # => returned default value

在有異常捕捉的ensure時，情形會稍有分歧：

def m1
 'return default'
ensure
 puts 'I am sure that it will be here!'
end

m1 # => return default

像這類情形，在ensure語句之前，不管能否顯示用return來前往，m1辦法都邑前往ensure之前的值， ensure語句只是確保以後的代碼塊puts 'I am sure that it will be here!'履行，然則不會從這裡前往。假如在ensure語句中顯示的用return來前往值時，情形就紛歧樣了。示例以下：

def m1
 return 'return default'
ensure
 return 'I am sure that it will be here!'
end

m1 # => I am sure that it will be here!

不管在ensure之前能否顯示前往，都只會前往ensure以後的值。

在有代碼塊干涉的情形下，又會有所分歧：

def m1
 p 'start ... '
 proc do
  p 'block start'
  return
  p 'block end'
 end.call
 p 'end ... '
end

m1

# 輸入成果：
#
# "start ... "
# "block start"

這個應當是在預感當中的，再看下一個：

def m1
 p 'start ... '
 -> do
  p 'block start'
  return
  p 'block end'
 end.call
 p 'end ... '
end

m1

# 輸入成果：
#
# "start ... "
# "block start"
# "end ... "

這裡多了一行"end ... "，緣由安在？這就是Proc和Lambda最年夜的差別，在他們當中的return 語句跳出去的目標感化域分歧，Proc會直接跳出全部辦法的挪用，而Lambda只會跳出本身的感化域，前往到辦法中持續履行，這一點須要非分特別留意。（在break中，Proc和Lambda的跳出方法和return是一樣的，前面就不再贅述了。）
break

先來看一個簡略的小例子：

result = [1, 2, 3, 4, 5].map do |i|
 i * 2
end

p result # => [2, 4, 6, 8, 10]

這個沒甚麼奇異的，那末看看上面這個，來猜猜它的輸入成果是甚麼？

result = [1, 2, 3, 4, 5].map do |i|
 break if i > 3
 i * 2
end
# FLAG
p result

是[1, 2, 3, nil, nil]？照樣[1, 2, 3]？照樣甚麼？謎底是nil，由於履行break後，直接跳到了FLAG ，也就是跳出了map辦法，而map辦法中的語句並沒有履行完，招致沒有任何前往值，為了驗證這個設法主意是准確的，我們可以應用Ruby說話的break可以帶前往值的特征來驗證一下：

result = [1, 2, 3, 4, 5].map do |i|
 break 'returned break' if i > 3
 i * 2
end

p result # => "returned break"

這裡可以證實我們的猜想是准確的。固然下面解釋了這個成績，然則應當還不長短常輕易懂得，我們本身界說一個代碼塊，再來講明一下：

def m1
 p 'start in m1 ... '
 m2 do # 代碼塊
  p 'start in block in m1 ... '
  p 'end in block in m1 ... '
 end
 p 'end in m1 ... '
end

def m2 &block
 p 'start in m2 ... '
 block.call
 p 'end in m2 ... '
end

m1

# 輸入成果：
#
# "start in m1 ... "
# "start in m2 ... "
# "start in block in m1 ... "
# "end in block in m1 ... "
# "end in m2 ... "
# "end in m1 ... "

然後我們在m1中的block中添加break，來看看履行成果：

def m1
 p 'start in m1 ... '
 m2 do # 代碼塊
  p 'start in block in m1 ... '
  break
  p 'end in block in m1 ... '
 end
 p 'end in m1 ... '
end

def m2 &block
 p 'start in m2 ... '
 block.call
 p 'end in m2 ... '
end

m1

# 輸入成果：
#
# "start in m1 ... "
# "start in m2 ... "
# "start in block in m1 ... "
# "end in m1 ... "

可以看到代碼塊的最初一行代碼沒有履行，m2的最初一行也沒有履行，就是由於這一行沒有履行，招致 break的第二個例子中的map沒有前往任何值。總結一下，代碼塊中的break會直接跳出挪用的辦法（m2），而在聲明朝碼塊的辦法（m1）中持續履行此辦法（m1）中剩下的語句。
next

next症結字相似其他說話中的continue，它的任務方法根本和continue相似。

def m1
 p 'start in m1 ... '
 m2 do # 代碼塊
  p 'start in block in m1 ... '
  next
  p 'end in block in m1 ... '
 end
 p 'end in m1 ... '
end

def m2 &block
 p 'start in m2 ... '
 block.call
 p 'end in m2 ... '
end

m1

# 輸入成果：
#
# "start in m1 ... "
# "start in m2 ... "
# "start in block in m1 ... "
# "end in m2 ... "
# "end in m1 ... "

只是略過了代碼塊的最初一行代碼，這就是next的任務方法了。我們再來看看break的誰人例子假如用next來寫，看看成果是甚麼？假如你完整懂得了下面所寫的，信任你曾經能在年夜腦上鉤算出成果了：

result = [1, 2, 3, 4, 5].map do |i|
 next if i > 3
 i * 2
end

p result # => [2, 4, 6, nil, nil]

next語句也能帶前往值：

result = [1, 2, 3, 4, 5].map do |i|
 next 'next' if i > 3
 i * 2
end

p result # => [2, 4, 6, "next", "next"]

其他

關於return，在辦法中，代碼塊中都可使用，而break和next只能在代碼塊中應用（輪回構造中也能夠應用，然則普通它也是用代碼塊的情勢來表現），假如在辦法中挪用二者會提醒語法毛病，也就是：

def m1
 return # OK
 break # Invalid break, compile error (SyntaxError)
 next  # Invalid next, compile error (SyntaxError)
end

結論

return 年夜部門情形下和其他說話無異，須要留意在ensure和Proc和Lambda兩種分歧的代碼塊中的細節成績。

break 在無方法嵌套挪用中的代碼塊中須要留意，它老是前往到挪用代碼塊辦法的辦法中（有點繞）。

next 最誠實，根本不須要留意甚麼。

最初就是，不只是return能前往值，break和next都能前往值。

p;                break;
                }
            }

            // 刪除末尾的0
            i = buffer.length() - 1;
            while (i >= 0) {
                if (buffer.length() > 2 && buffer.charAt(i-1) == '.') { // 小數點後直接是數字
                    break;
                } else if (buffer.charAt(i) == '0') { // 刪除末尾的0
                    buffer.deleteCharAt(i);
                    i = buffer.length() - 1;
                    continue;
                } else { // 當最初一名不是0的時刻
                    break;
                }
            }
        }

        // 依據符號位, 前往值的正負標記
        if (flag) {
            return "-" + buffer.toString();
        } else {
            return buffer.toString();
        }
    }

    /**
     * 將字符串裝換為數組
     * @param number
     * @return
     */
    private static int[] string2IntArray(String number) {
        // 斷定輸出能否相符浮點數的請求
        Pattern pattern = Pattern.compile("^(-?\\d+|\\d*)\\.?\\d*$");
        Matcher matcher = pattern.matcher(number);
        if (!matcher.find()) {
            throw new IllegalArgumentException("輸出的數不准確!");
        }

        int[] result = new int[number.length()];
        for (int i = 0; i < number.length(); i++) {
            result[i] = (int) (number.charAt(i) - '0');
        }
        return result;
    }
}

運轉成果以下:

1. 毛病輸出的斷定

Input two large integers:
1a*a22
Exception in thread "main" java.lang.IllegalArgumentException: 輸出的數不准確!
at BigNumber.string2IntArray(BigNumber.java:132)
at BigNumber.bigNumberMultiply(BigNumber.java:54)
at BigNumber.main(BigNumber.java:22)

2. 帶正數的運算, 前後帶有0的情形

Input two large integers:
-23424.2300*02345.23400000
-54935300.61982

python上鉤算的成果以下

Python 2.6.5
>>> -23424.2300*02345.23400000
-54935300.619819999

可以看出python的成果是有掉真的