Programa Java para Calcular la Suma de Números en una Lista Usando Recursión

ArrayList es parte del marco Collection y está presente en el paquete java.util. Nos proporciona arreglos dinámicos en Java. Sin embargo, puede ser más lento que las arrays estándar, pero puede ser útil en programas donde se necesita mucha manipulación en la array. Esta clase se encuentra en el paquete java.util. 

Ilustración:

Input  : [1, 3, 9]  
Output : 13

Aquí, el método ingenuo puede ser sumar elementos de Lista y mantener un contador en el que se almacena la suma mientras se recorre Lista. El método paso adelante puede ser convertir la Lista en la array y hacer lo mismo. Ahora, el método más óptimo puede ser usar la recursión mientras se hace, en la que la subparte de la Lista o array se calcula automáticamente mediante los principios de recursión. Aquí este enfoque óptimo se describe e implementa como se muestra. 

Métodos:

1. Conversión de ArrayList en arrays y uso de principios de recursión sobre arrays.
2. Usando el método ArrayList.add()

Método 1: convertir ArrayList en arrays y usar principios de recursión sobre arrays. 

Se logra convirtiendo ArrayList en arreglos y usando principios de recursión sobre arreglos. Recursividad en la lista para la conversión de arrays y el cálculo de la suma de los elementos mediante el método add().

Acercarse: 

1. Tome los elementos de la lista como entrada del usuario.
2. Convierta la lista en una array del mismo tamaño.
3. Añádele los elementos.
4. Calcule la suma de arrays usando principios de recursión.

Ejemplo

// Java Program to Compute Sum of Numbers in a List
// by converting to arrays and applying recursion
 
// Importing java input/output classes
import java.io.*;
// Importing List and ArrayList class from
// java.util package
import java.util.ArrayList;
import java.util.List;
 
// Class
public class GFG {
 
    // Method to calculate sum recursively
    public static int sumOfArray(Integer[] a, int n)
    {
        if (n == 0)
            return a[n];
        else
            return a[n] + sumOfArray(a, n - 1);
    }
 
    // Method- main()
    public static void main(String[] args)
    {
        // Creating a List of Integer type
        // Declaring an object- 'al'
        List<Integer> al = new ArrayList<Integer>();
 
        // Adding elements to the List
        // Custom inputs
        al.add(1);
        al.add(2);
        al.add(3);
        al.add(4);
        al.add(5);
 
        // Converting above List to array
        // using toArray() method
        Integer a[] = new Integer[al.size()];
        al.toArray(a);
 
        // Display message
        System.out.print("Elements in List : ");
 
        // Printing array of objects
        // using for each loop
        for (Integer obj : a) {
            System.out.print(obj + " ");
        }
 
        // Recursion math to calculate sum snd
        // storing sum in a variable
        int sum = sumOfArray(a, a.length - 1);
 
        // Next line
        System.out.println();
 
        // Print the sum returned above
        System.out.println("Sum of elements  : " + sum);
    }
}

Elements in List : 1 2 3 4 5 
Sum of elements  : 15

Método 2: Usar el método ArrayList.add()

Este método agrega el elemento especificado al final de esta lista

Sintaxis:

public boolean add(E element) ;

Parámetro: Objeto que se agregará a esta lista.

Tipo de devolución: siempre devolverá un booleano verdadero y la firma es así porque otras clases en la familia de colecciones necesitan un tipo de devolución.

Excepciones: NA

Ejemplo:

// Java Program to Compute the Sum of Numbers in a List
// using Recursion via ArrayList.add() method
 
// Importing all classes of
// java.util package
import java.util.*;
 
// Class
public class GFG
{  
  // Declaring variables outside main class
  int sum = 0, j = 0;
 
  // Main driver method
  public static void main(String[]args)
  {
    /*
    // Taking the input from the user
    int n;
    Scanner s = new Scanner(System.in);
 
    // Display message
    System.out.print("Enter the no. of elements :");
     
    // Reading integer elements using nextInt() method
    n = s.nextInt();
 
    // Display message
    System.out.println("Enter all the elements you want:");
    */
 
    // Creating an object of List of Integer type
    List < Integer > list = new ArrayList < Integer > ();
 
    // Adding elements to object of List
    // Custom inputs to show sum
    list.add(10);
    list.add(90);
    list.add(30);
    list.add(40);
    list.add(70);
    list.add(100);
    list.add(0);
     
    System.out.println("Elements in List : " + list);
    /*
    // If input is through user than
     
    // For loop to add elements inside List
    for (int i = 0; i < n; i++)
    {
      // Adding integer elements in the list
      list.add(s.nextInt());
    }
    */
 
    // Converting List to Array
    Integer[] a = list.toArray(new Integer[list.size()]);
 
    // Initialising object of Main class
    GFG elem = new GFG();
 
    // Finding sum of elements in array
    // via add() method using recursion
    int x = elem.add(a, a.length, 0);
     
    // Print the sum of array/elements initially in List
    System.out.println("Sum of elements in List :" + x);
  }
 
  // add() method to add elements in array
  // using recursion
  int add(Integer arr[], int n, int i)
  {
    if(i < n)
    {
        return arr[i] + add(arr, n, ++i);
    }
    else
    {
        return 0;
    }
  }
}

Elements in List : [10, 90, 30, 40, 70, 100, 0]
Sum of elements in List :340