¿Por qué es una de las variables en un objeto que se cambió dentro de un constructor?

Deema Bowgen:

Me disculpo por la pregunta mal formulada - es difícil de explicar consisely.

He escrito 3 clases - uno para representar los números complejos, uno en representación de polinomios con coeficientes complejos y la final para realizar el algoritmo de Newton-Raphson en dichos polinomios para encontrar las estimaciones de las raíces.

El problema es, cuando i crear una instancia de la clase Newton, siendo este el constructor:

public Newton(Polynomial p) {
       this.f = p;
       this.fp = this.f.derivative();

que no tiene problemas con la configuración f ap, pero luego, cuando

this.fp = this.f.derivative();

se ejecuta cambia this.f a this.f.derivative (); también.

este es el código para el derivado de:

public Polynomial derivative() {
        ArrayList<Complex> derivativeCoeff = coeff;
        if (derivativeCoeff.size() == 1){
            return new Polynomial();
        }
        derivativeCoeff.remove(0);
        for (int i = 1; i <= derivativeCoeff.size() ;i++){
            derivativeCoeff.set(i-1,derivativeCoeff.get(i-1).multiply(i));

        }
        Polynomial test = new Polynomial(derivativeCoeff);
        return test;  
    }

Esta es la principal de Newton:

ArrayList<Complex> coeff = new ArrayList<Complex>();
        coeff.add(new Complex(-1.0,0.0));
        coeff.add(new Complex());
        coeff.add(new Complex());
        coeff.add(new Complex(1.0,0.0));

        Polynomial p = new Polynomial(coeff);
        System.out.println("the polynomial being used = "+p);
        Newton n = new Newton(p);

        System.out.println("f = "+n.getF());
        System.out.println("fp = "+n.getFp());

y esto es la salida me sale:

the polynomial being used = (-1.0+0.0i)+(0.0+0.0i)X+(0.0+0.0i)X^2+(1.0+0.0i)X^3
f = (0.0+0.0i)+(0.0+0.0i)X+(3.0+0.0i)X^2
fp = (0.0+0.0i)+(0.0+0.0i)X+(3.0+0.0i)X^2

cuando f debe ser igual a p.

Por favor, pregunte si se requiere más información o código. No tengo experiencia con hacer preguntas sobre SO y agradecería cualquier ayuda que pueda conseguir.

Andy Turner:

ArrayList<Complex> derivativeCoeff = coeff;

No copia la lista: la actualización de derivativeCoeffcambios coefftambién.

Tome una copia:

ArrayList<Complex> derivativeCoeff = new ArrayList<>(coeff);

O bien, puede eliminar el primer elemento antes de tomar la copia (obviamente la comprobación de vacío primero):

ArrayList<Complex> derivativeCoeff = new ArrayList<>(coeff.subList(1, coeff.size()));

O puede copiar y actualizar los elementos directamente con un arroyo.

ArrayList<Complex> derivativeCoeff =
    IntStream.rangeClosed(1, coeff.size() - 1)
        .mapToObj(i -> coeff.get(i).multiply(i))
        .collect(Collectors.toCollection(ArrayList::new));

O incluso

return
    IntStream.rangeClosed(1, coeff.size() - 1)
        .mapToObj(i -> coeff.get(i).multiply(i))
        .collect(
            Collectors.collectingAndThen(
                Collectors.toCollection(ArrayList::new)),
                Polynomial::new));