¿Por qué es posible modificar un ArrayList de objetos personalizados en un bucle para cada uno ...

Kinnison84:

Tenemos un simple objeto personalizado:

public class CustomObject {
    public CustomObject(int myIntNumber, String myString) {
    this.myIntNumber = myIntNumber ;
    this.myString = myString;    
    }

    private int myIntNumber;
    private String myString;

    public void setMyIntNumber(int myIntNumber) {
    this.myIntNumber = myIntNumber;
}

public int getMyIntNumber() {
    return myIntNumber;
}

public void setMyString(String myString) {
    this.myString = myString;
}

public String getMyString() {
    return myString;
}


    public String toString() {
        return "CustomObject [" + String.valueOf(myIntNumber)  + ", "+ myString+"]" ;  
    }
}

y, tratamos de modificar un ArrayList de tales objetos con un lazo para cada .... ¿Por qué los objetos de la lista se modifican, cuando un ArrayList de objetos String o de objetos de enteros no puede ser modificado de esta manera?

Mi código de prueba:

import java.util.ArrayList;

public class TestTraveringListModification {

    public static void main(String[] args) {

    ArrayList<String> sList  = new ArrayList<String>();
    sList.add("String a");
    sList.add("String b");
    sList.add("C");
    sList.add("D");
    sList.add("String f");
    sList.add("String e");

    System.out.println("Before: "+sList);
    for (String s : sList) {
        s="asdf" ;

    }

    System.out.println("After: "+ sList);

    ArrayList<CustomObject> objL = new ArrayList<CustomObject> () ;
    objL.add(new CustomObject (1, "test") );
    objL.add(new CustomObject (2, "jim") );
    objL.add(new CustomObject (20, "dec") );
    objL.add(new CustomObject (60, "what") );
  System.out.println("before: "+ objL );
    for(CustomObject co : objL ){    
        co.setMyIntNumber(-1);
        co.setMyString("modified String");
    }
    System.out.println("after: "+objL);


    ArrayList<Integer> numList = new ArrayList<Integer>(); 

    numList.add(1);
    numList.add(3);
    numList.add(5);
    numList.add(67);
    numList.add(9598);

    System.out.println("before: "+ numList);

    for (Integer i : numList){
        i = 8; 
    }
    System.out.println("after: "+ numList);

}
}

La ejecución de este producirá el siguiente resultado:

Before: [String a, String b, C, D, String f, String e]

After: [String a, String b, C, D, String f, String e]

before: [CustomObject [1, test], CustomObject [2, jim], CustomObject [20, dec], CustomObject [60, what]]

after: [CustomObject [-1, modified String], CustomObject [-1, modified String], CustomObject [-1, modified String], CustomObject [-1, modified String]]

before: [1, 3, 5, 67, 9598]

• elemento de la lista

  after: [1, 3, 5, 67, 9598]

Así que, ¿por qué es que puedo modificar objL y no slist o numlist?

engañar:

Debido a la reasignación y la mutación son dos cosas diferentes.

s = "asdf"va a cambiar lo que sse hace referencia. Se utiliza para contener una referencia a un miembro de sList, ahora se refiere a "asdf". El cambio no tiene nada que ver con el miembro de sList.

Similar con iy numList, aunque no del todo exactamente igual. numListcontiene Integerobjetos, autoboxed de 1, 3, 5... forva a asignar el valor a objetos enteros i. Si cambia el valor de ia (autoboxed) Integer(8), sino que también no afecta a numListninguna.

Sin embargo, con coy objL, haces una cosa muy diferente. En lugar de reasignar coa otro objeto (que no afectaría a los objetos en objL), que eligió para invocar métodos sobre co, que luego pasó a cambiar su estado. Tenga en cuenta que aquí está no modificando objL, que se está modificando los objetos que contiene.

La idea clave es que i, coy sno son elementos de las listas respectivas. Ellos contienen valores que podrían ser elementos de las listas (pero de nuevo, en caso de autounboxing, esto también no se sostiene).