將幾種方法合併到一箇中。泛型

Question

我有一些代碼來找出不同數據類型（int，long，double）與BigInteger比較的操作的正確性。操作獲取一個數字的階乘，直到結果與BigInteger相同。

問題是我該如何改變我的代碼，使更通用，緊湊和乾淨？我怎麼能得到唯一的方法，而不是4不同類型的？ 此方法中的邏輯與流程相同。

代碼（而不比較邏輯）是：

private static HashMap<BigInteger, BigInteger> bigIntegerFactorials = new HashMap<>(); 
private static BigInteger bigIntegerFactorial(BigInteger number) { 
    if (number.equals(BigInteger.ONE)) { 
     return BigInteger.ONE; 
    } 
    BigInteger result = bigIntegerFactorials.get(number); 
    if (result == null) { 
     result = number.multiply(bigIntegerFactorial(number.subtract(BigInteger.ONE))); 
     bigIntegerFactorials.put(number, result); 
    } 
    return result; 
} 

private static HashMap<Integer, Integer> intFactorials = new HashMap<>(); 
private static int intFactorial(int number) { 
    if (number == 1) { 
     return 1; 
    } 
    Integer result = intFactorials.get(number); 
    if (result == null) { 
     result = number * intFactorial(number - 1); 
     intFactorials.put(number, result); 
    } 
    return result; 
} 

private static HashMap<Long, Long> longFactorials = new HashMap<>(); 
private static long longFactorial(long number) { 
    if (number == 1) { 
     return 1L; 
    } 
    Long result = longFactorials.get(number); 
    if (result == null) { 
     result = number * longFactorial(number - 1); 
     longFactorials.put(number, result); 
    } 
    return result; 
} 

private static HashMap<Double, Double> doubleFactorials = new HashMap<>(); 
private static double doubleFactorial(double number) { 
    if (number == 1) { 
     return 1.; 
    } 
    Double result = doubleFactorials.get(number); 
    if (result == null) { 
     result = number * doubleFactorial(number - 1); 
     doubleFactorials.put(number, result); 
    } 
    return result; 
} 

非常感謝提前。

Answer 1

你可以通過乘法和遞減函數的一般方法：

private static Map<Number, Number> factorials = new HashMap<>(); 

private static <T extends Number> T factorial(T n, BinaryOperator<T> multiply, UnaryOperator<T> decrement) { 
    if (n.doubleValue() == 1) return n; 
    T result = (T) factorials.get(n); 
    if (result == null){ 
    result = multiply.apply(n, factorial(decrement.apply(n), multiply, decrement)); 
    factorials.put(n, result); 
    } 
    return result; 
} 

然後你就可以改變你的原始方法如下：

public static int intFactorial(int number) { 
    return factorial(number, (i, j) -> i * j, i -> i - 1); 
} 

警告：這種方法似乎崩潰，但Netbeans的編譯罰款用javac ...

Answer 2

如果你真的想計算一個階乘，那麼double或BigDouble自factorial only applies to integer values以後就沒有任何需要。而且，既然是這樣，你可以將任何整數類型轉換爲BigInteger，並採用一種方法，其中任何Number返回BigInteger。

這是一個測試類

public class Junk { 
    public static void main(String[] args) { 
     long val = 9; 
     Junk j = new Junk(); 
     System.out.println(val + "! = " + j.factorial(val)); 
     BigInteger nine = new BigInteger("9"); 
     System.out.println(nine + "! = " + j.factorial(nine)); 
     short nine_short = 9; 
     System.out.println(nine_short + "! = " + j.factorial(nine_short)); 
    } 

    private HashMap<BigInteger, BigInteger> map = new HashMap<>(); 


    public BigInteger factorial(Number number){ 
     if(1 == number.intValue()){ 
      return BigInteger.ONE; 
     } 

     BigInteger bigInteger = new BigInteger(number.toString()); 
     BigInteger result = map.get(bigInteger); 

     if(result == null){ 
      result = bigInteger.multiply(factorial(bigInteger.subtract(BigInteger.ONE))); 
      map.put(bigInteger,result); 
     } 

     return result; 
    } 
} 

和輸出

9! = 362880 
9! = 362880 
9! = 362880