¿Cómo pasar el objeto ArrayList como argumento de función en java?

La clase ArrayList en Java es básicamente una array que puede cambiar de tamaño, es decir, puede crecer y reducir su tamaño dinámicamente de acuerdo con los valores que agregamos o eliminamos de ella. Está presente en el paquete java.util . Si queremos pasar un ArrayList como argumento a una función, podemos hacerlo fácilmente usando la sintaxis que se menciona a continuación.

Ejemplo:

ArrayList<Integer> list = new ArrayList<>();
modifyList(list);
public static void modifyList(ArrayList<Integer> list){
       list.add(69);
       list.add(98);
}

En el código anterior, creamos un objeto ArrayList llamado ‘lista’ y luego lo pasamos a una función llamada modificarLista. Los cambios que hicimos en esta lista (es decir, los valores que agregamos a la lista) aparecerán en la lista original dentro de la función principal. Esto sucede porque las referencias de objetos se pasan por valor en java, ya que java se pasa estrictamente por valor . 

Implementación del enunciado del problema:

// Java program to pass an
// ArrayList as an argument
  
import java.util.*;
  
public class GFG {
  
    public static void main(String[] args)
    {
        // Creating an ArrayList Object of Integer type
        ArrayList<Integer> list = new ArrayList<>();
  
        // Inserting some Integer values in ArrayList
        list.add(3);
        list.add(57);
        list.add(7);
  
        // list after insertions : [3, 57, 7]
        // Displaying the ArrayList
        System.out.print("ArrayList after insertions: ");
        display(list);
  
        // Passing the ArrayList as an argument for
        // modification The modifications done to the list
        // inside the function will appear inside the
        // original ArrayList inside main()
        modifyList(list);
  
        // list after modifications : [3, 57, 7, 20, 98]
        // displaying the ArrayList after modifications
        System.out.print("ArrayList after modifications: ");
        display(list);
    }
  
    // Function to modify the arrayList
    public static void
    modifyList(ArrayList<Integer> parameterList)
    {
        parameterList.add(20);
        parameterList.add(98);
    }
  
    // Function to display the array List
    public static void display(ArrayList<Integer> list)
    {
        System.out.println(list);
    }
}

ArrayList after insertions: [3, 57, 7]
ArrayList after modifications: [3, 57, 7, 20, 98]

¿Cómo se pasa Java por valor?

Supongamos que el objeto Array list que creamos dentro de la función principal apunta a una dirección 1000. Cuando pasamos este objeto a la función modifyList, se le pasa la dirección 1000 y el objeto ‘parameterList’ también comienza a apuntar a la misma ubicación dentro de la memoria como la de ‘lista’, es por eso que dijimos que las referencias a objetos se pasan por valor en java. Después de eso, cuando hicimos modificaciones a ‘parameterList’, se realizaron los mismos cambios en la ‘lista’ original. Este concepto es muy similar a lo que sucede en C++ cuando pasamos una variable de puntero como argumento.

ArrayList<Integer> list = new ArrayList<>();
callByValue(list);
public static void callByValue(ArrayList<Integer> parameterList){
       parameterList = new ArrayList<>();
       parameterList.add(88);
       parameterList.add(200);
       parameterList.add(89);
}

En el código anterior, cuando pasamos la lista a la función callByValue, ‘parameterList’ comienza a apuntar a la dirección de memoria, es decir, 1000. Pero cuando creamos una nueva instancia de ArrayList e hicimos que ‘parameterList’ apunte a ella, entonces ‘parameterList’ comienza a apuntar a una nueva dirección de memoria (digamos) 2000. Los cambios realizados en ArrayList dentro de esta función ya no afectarán a ArrayList en la dirección de memoria 1000. Por lo tanto, la ‘lista’ dentro de la función principal no se ve afectada.

A continuación se muestra la implementación del enunciado del problema: 

// Java program to pass an
// ArrayList as an argument
  
import java.util.ArrayList;
  
public class GFG {
  
    public static void main(String[] args)
    {
  
        // Creating an ArrayList Object of Integer type
        ArrayList<Integer> list = new ArrayList<>();
        // Inserting some Integer values in ArrayList
        list.add(3);
        list.add(57);
        list.add(7);
  
        // list after insertions : [3, 57, 7]
  
        // Displaying the ArrayList
        System.out.print("ArrayList after insertions: ");
        display(list);
  
        // The changes made to the ArrayList inside this
        // function will not affect the original ArrayList
        // that we pass to it as we are simply creating the
        // new instance of ArrayList and making our
        // parameterList point to it
        callByValue(list);
  
        // list after function call : [3, 57, 7]
  
        // displaying the ArrayList after calling
        // callByValue
        System.out.print(
            "ArrayList after the function call: ");
        display(list);
    }
  
    public static void
    callByValue(ArrayList<Integer> parameterList)
    {
  
        // Creating a new instance of ArrayList
        parameterList = new ArrayList<>();
  
        // Inserting Integer values to the new ArrayList
        // created inside the function
        parameterList.add(88);
        parameterList.add(200);
        parameterList.add(89);
  
        // Displaying our new ArrayList
        System.out.print(
            "New ArrayList inside the function: ");
        display(parameterList);
    }
  
    // Function to display the array List
    public static void display(ArrayList<Integer> list)
    {
        System.out.println(list);
    }
}

ArrayList after insertions: [3, 57, 7]
New ArrayList inside the function: [88, 200, 89]
ArrayList after the function call: [3, 57, 7]