En ajoutant les éléments d'un double tableau [], sans l'aide d'une boucle en java

Non, vous ne pouvez pas calculer la somme d'une liste de valeurs en une seule étape. Même si il y avait une méthode de l'API ou une bibliothèque qui offre une fonction somme, elle serait d'utiliser des boucles en interne. La complexité de la somme de l'algorithme est O(n) (pour un seul Cpu).

Un moyen de sortir pourrait être l'aide d'un calcul en parallèle, mais c'est une approche théorique pour répondre à votre question. Vous avez besoin d'au moins autant de Processeurs que les cellules de tableau pour calculer la somme sur l'étape. (Ou une fiction CPU avec autant de FP registres sous forme de tableau de valeurs).

---

Avant de vous commencer à regarder les API de Java ou d'autres bibliothèques:

 public static double sum(double...values) {
   double result = 0;
   for (double value:values)
     result += value;
   return result;
 }

Utilisation:

 double sum = sum(array);  //this is in your main code -> no loop (visible)

OriginalL'auteur Andreas_D

Tout d'abord, des "centaines" n'est pas "énorme" ('millions') et la seconde, d'ajouter les éléments sans boucle n'est pas possible à moins d'avoir une information préalable sur les éléments (comme si elles font partie d'une série en particulier).

OriginalL'auteur Abhinav Sarkar

Je préfère l'approche suivante.

package rfcampusdata;

public class TestClass {
  public static void main(String[] args) {
    String str = "1,2,3,4,5";
    String[] arr = str.split(",");
    int length = arr.length;

    System.out.println(sum(length, arr));
  }

  static Double temp = new Double(0);

  public static Double sum(int length, String[] arr) {
    int length_m = length - 1;
    String[] arr_m = arr;
    temp += Double.parseDouble(arr[length_m]);
    if (length_m != 0) {
      sum(length_m, arr_m);
    } else {
      //temp += Integer.parseInt(arr[0]);
      //System.out.println(temp);
    }
    return temp;

  }

OriginalL'auteur Pradip Wawge

Si vous êtes vraiment intéressé, une précision, une simple boucle pourrait causer certains problèmes. Les Doubles ne contiennent pas de précision arbitraire. Voici un exemple simple pour montrer la faille de simplement en utilisant une boucle.

float f = 0;
for(int i = 0; i < 1000*1000*1000; ++i){
    ++f;
}
System.out.println(f);

Nous espérons que f sera de 1 milliard de dollars, ou 1.0E9, mais au lieu de cela, nous obtenons 1.6777216E7. C'est parce que le flotteur ne peut contenir environ 6 à 7 chiffres de précision. Un double peut contenir environ 16-17 chiffres de précision ce qui signifie qu'il est moins susceptible d'avoir un problème, mais ça ne résout pas le problème.

Pour contourner ce problème, nous avons besoin de ne pas additionner deux nombres lorsqu'il y a une grande différence de magnitude entre eux. Cela peut être fait en utilisant un PriorityQueue. Nous allons prendre les 2 premiers numéros, les ajouter, puis les remettre dans la file d'attente. Lorsque la file d'attente a seulement 1 nombre de gauche, nous le retourner.

public static double queueSum(double[] da){
    PriorityQueue<Double> pq = new PriorityQueue<Double>(da.length);
    for(double d : da)
        pq.add(d);
    while(pq.size() > 1)
        pq.add(pq.poll() + pq.poll());
    return pq.poll();
}

Bien sûr précision, ne viennent au coût du temps. Cela va de la boucle du montant de O(n) à O(n lg n)) pour ne pas mentionner les frais généraux des objets concernés.

Parce doubles disposent de beaucoup plus de précision que d'un flotteur, vous n'aurez probablement pas besoin d'utiliser cette information si vous avez un grand nombre de doubles (des millions/milliards de dollars) et/ou vous avez une grande différence d'ampleur entre vos numéros.

Edit:
Si tous les nombres ont environ le même ordre de grandeur, ce code permettra d'éviter le problème de l'entretenir O(n) fois. Si il y a une grande différence de grandeur entre les deux échantillons ou les numéros sont distribués d'une façon qui pourrait entraîner une grande différence de grandeur, il ne pouvait souffrir les mêmes problèmes qu'avant.

public static double treeSum(double[] da){
    double[] dc = da.clone();
    int len = dc.length;
    while(len > 1){
        len = (len + 1) / 2;
        for(int i = 0; i < len; ++i)
            dc[i] += dc[i + len];
        dc[len] = 0;
    }
    return dc[0];
}

OriginalL'auteur GuiltyBystander

si le type de données dans votre tableau est le type d'objet Double ,pas le type de primitive double,alors vous pouvez utiliser flux dans java 8 comme ceci:

Double[] test = new Double[] {2.0, 3.1, 4.2, 8.9, 10.11};
List<Double> list = Arrays.asList(test);
double sum = list.stream().mapToDouble(p -> p).sum();
System.out.println(sum);

OriginalL'auteur howie

La boucle est le moyen le plus simple pour cela, mais puisque vous avez demandé pour un autre:

La récursivité:

double sumResult = sum(data, 0, 0);

double sum(double [] d, int sum, int index) {
  if ( index > d.length ) return sum;
  else return sum(d, sum + d[index], index+1);
}

Je n'ai pas testé, mais il devrait fonctionner quelque part le long de la ci-dessus.

EDIT: Il n'est pas recommandé d'utiliser une telle construction, puisque, pour la très vaste gamme, vous pouvez frapper la StackOverflowException très rapide.

OriginalL'auteur ZeissS

Amis c'est la solution parfaite que j'ai fait.Je prends condition complexe avec de la ficelle. nous pouvons utilisé directement un double tableau.

public class TestClass {
  public static void main(String[] args) {
    String str = "1,2,3,4,5";
    String[] arr = str.split(",");
    int length = arr.length;

    System.out.println(sum(length, arr));
  }

  static Double temp = new Double(0);

  public static Double sum(int length, String[] arr) {
    int length_m = length - 1;
    String[] arr_m = arr;
    temp += Double.parseDouble(arr[length_m]);
    if (length_m != 0) {
      sum(length_m, arr_m);
    } else {
      //temp += Integer.parseInt(arr[0]);
      //System.out.println(temp);
    }
    return temp;

  }

bonne journée!!!!!!!

OriginalL'auteur Pradip Wawge