打印不同長度的數組

Question

我正在寫一個程序，它打印一個數組，其中包含作爲參數傳遞的兩個數組值的總和。當一個數組比另一個長時，我需要包含異常。在這種情況下，該方法應該打印這兩個數組共享的索引的總和，然後打印沒有相應值添加到的數組值。

這裏的問題是，我每次去編譯程序的時候，我得到一個消息，說： Sum.java:51：找不到符號 符號：變量蘇梅 位置：類點心 蘇梅[J]。 = x [j] + y [j]; ^ 1錯誤

import java.util.*; 

class Sum 
{ 
    public static void main (String [] args) 
    { 
     double [] a1 = {4.5, 2.8, 3.4, 0.8}; 
     double [] a2 = {1.4, 8.9, -1.0, 2.3}; 

     arraySum (a1, a2); 

     System.out.println (Arrays.toString (arraySum (a1, a2))); 
    } 

    public static double [] arraySum (double [] x, double [] y) 
    { 
     int length = 0; 

     if (x.length < y.length) 
     { 
      double [] sumY = new double [y.length]; 
      length = y.length; 

      for (int i = 0; i <= y.length - 1; i++) 
      { 
       for (int j=0; j <= x.length-1; j++) 
       { 
        sumY [j] = x[j] + y[j]; 
       } 

       sumY [(x.length -1) + i] = y[i]; 
      } 

      return sumY;   
     } 

     if (x.length > y.length) 
     { 
      double [] sumX = new double [x.length]; 
      length = x.length; 

      for (int i = 0; i <= x.length - 1; i++) 
      { 
       for (int j=0; j <= y.length-1; j++) 
       { 
        sumY[j] = x[j] + y[j]; 
       } 

       sumX [(y.length -1) + i] = y[i]; 
      } 

      return sumX; 
     } 

     else 
     { 
      double [] sum = new double [x.length]; 
      length = x.length; 

      for (int i = 0; i <= length - 1; i++) 
      { 
       sum[i] = x[i] + y[i]; 
      } 

      return sum; 
     } 

    } 
} 

Answer 1

這是因爲最接近double至2.3和最接近double至0.8，當加在一起，不給最接近double〜3.1。

如果您打算使用精確小數進行算術運算，並期望得到正確答案，您應該使用BigDecimal類而不是double。

Answer 2

1：不要使用Arrays.toString的，使用

System.out.printf("["); 
double[] sum = arraySum(a1, a2); 
for (int i = 0; i < sum.length; i++) { 
    System.out.printf("%0.1f", sum[i]); 
    if(i != sum.length - 1) { 
     System.out.printf(", "); 
    } 
} 
System.out.printf("]\n"); 

2：在第二，如果塊，你使用蘇梅，我猜想你的意思是SUMX。 sumY沒有在該範圍內定義，所以它給你一個錯誤。

Answer 3

您還可以通過實現方法縮短代碼。在這種情況下，我稱它爲altMethod。此外，您應該注意altMethod不使用for循環內 a for循環，而是一個接着一個。第一個填充總和，而索引可以配對，下一個只填充剩下的索引。

import java.util.Arrays; 

public class MySum { 

    public static void main (String [] args) { 
     double [] a1 = {4.5, 2.8, 3.4, 0.8}; 
     double [] a2 = {1.4, 8.9, -1.0, 2.4}; 

     System.out.println (Arrays.toString (arraySum(a1, a2))); 
    } 

    public static double [] arraySum (double [] x, double [] y) { 

     if (x.length < y.length) { 
      return altMethod(x, y); 
     } 

     if (x.length > y.length) { 
      return altMethod(y, x); 
     } 

     else { 
      return altMethod(x, y); 
     } 

    } 

    public static double[] altMethod(double[] smaller, double[] bigger) { 
     int length = 0; 
     double[] answer = new double[bigger.length]; 

     for(int i = 0; i < smaller.length ; i++) { 
      answer[i] = smaller[i] + bigger[i]; 
      length++; 
     } 

     for(;length < bigger.length; length++) { 
      answer[length] = bigger[length]; 
     } 

     return answer; 
    } 
} 

altMethod不得不以某種順序參數。正在(smaller, bigger)但不是(bigger, smaller)。