objectMapper.readValues

Saludos...

Tengo lo siguiente :
for(Prediocaract row : lstPrediocaract){
Prediocaract prediocaract = new Prediocaract();
...........
}
Como puedo hacer para que la informacion que contiene row se copie a la instancia prediocaract sabiendo que ambos tienen la misma estructura.

en forma manual se puse hacer de una a una ose : prediocaract.setPeriodo(row.getPeriodo) ; y asi susecivamente.,,,, pero son muchos campos entonces como se podria hacer en menos pasos...

Espero pueden ayudarme

AT...

CArlos A. Rojas C.
peru.

Opciones de visualización de comentarios

Seleccione la forma que prefiera para mostrar los comentarios y haga clic en «Guardar las opciones» para activar los cambios.
Imagen de ezamudio

clone?

Pues sólo que implementara Cloneable tu clase...

Imagen de juan_dllo

Objeto

En caso de que la clase no implemente Cloneable y al ser instancias del mismo objeto que tan recomendable es hacer:

 for(Prediocaract row : lstPrediocaract){
  Prediocaract prediocaract = new Prediocaract();
  prediocaract = row;
  ...........
 }

claro, si es que funciona que no estoy seguro, de ahí mi pregunta.

Saludos desde Colombia.

Imagen de arterzatij

una es como dice el buen

Esto no es recomendable

for(Prediocaract row : lstPrediocaract){
  Prediocaract prediocaract = new Prediocaract();
  prediocaract = row;
  ...........
 }

De hecho ni si quiera es una copia del objeto, lo que estas indicando ahi es que ahora tendras dos variable (apuntadores muy en el fondo) a una misma instancia ( espacio de memoria muy en el fondo). Y en el ciclo al final prediocaract tendra asignada la instancia del ultimo elemento del array o lista que estas iterando.

Lo mejor es como dice el buen Zamudio implementando cloneable

clonable
public class Prediocaract implements Cloneable {
  // codigo por aqui

  public Prediocaract clone() {
     Prediocaract prediocaract = new Prediocaract();

     prediocaract.setPeriodo( this.periodo );
     // y asi susecivamente

  }

   //mas codigo por aca
   
}

usando el metodo clone()
for ( Prediocaract row : lstPrediocaract ){
  Prediocaract prediocaract = row.clone();
}

la otra es que crees un constructor en tu clase que se cree desde una instancia del mismo tipo

contructor
public Prediocaract( Prediocaract row ) {
   this.periodo = row.getPeriodo();
   // y asi susecivamente
}
usando el constructor
for ( Prediocaract row : lstPrediocaract ){
  Prediocaract prediocaract = new Prediocaract( row );
}

Ahora que si no tienes acceso a esa clase lo que puedes hacer es una clase que te genere los objetos

Clonador
public class PrediocaractFactory {

  public static Prediocaract clone( Prediocaract  row ) {
     Prediocaract prediocaract = new Prediocaract();

     prediocaract.setPeriodo( row.getPeriodo() );
     // y asi susecivamente

  }

 
}

usando la clase clonadora
for ( Prediocaract row : lstPrediocaract ){
  Prediocaract prediocaract = PrediocaractFactory.clone( row );
}

Es decir ese "y asi susecivamente" no te lo evitaras solo lo moveras a otro lado para que lo puedas reutilizar en caso de que lo necesites mas de una ocacion en otra parte de tu aplicacion.

Imagen de ezamudio

um

Así no se implementa Cloneable. Si así fuera, no lo hubiera sugerido porque simplemente moviste todo el código que el OP no quería escribir, a otro lugar.

Si se implementa, debe

Si se implementa, debe hacerse cuidadosamente, porque de lo contrario acarrearía algunos problemas. Es más sencillo no implementarlo.

BeanUtils.cloneBean y SerializationUtils.clone

pero son muchos campos entonces como se podria hacer en menos pasos...

  • Con Apache Commons BeanUtils:
    Prediocaract prediocaract  = (Prediocaract ) org.apache.commons.beanutils.BeanUtils.cloneBean(row);

    NOTA: Debido a que este método utiliza Reflection, es necesario atrapar y manejar algunas excepciones que éste lanza.

  • Con Apache Commons Lang:

    Prediocaract prediocaract  = (Prediocaract ) org.apache.commons.lang.SerializationUtils.clone(row);

    NOTA: Para que este método funcione, Prediocaract debe implementar java.io.Serializable.

Imagen de arterzatij

De hecho no jeje se

De hecho no jeje se implementa asi o almenos asi lo he visto y lo he implementado

public Object clone()
{
    Object clone = null;
    try
    {
        clone = super.clone();
    }
    catch(CloneNotSupportedException e)
    {
        // No deberia suceder
    }
    return clone;
}

lo propuse asi por si esta bloqueada la clonacion uno nunca sabe. Y como lo puse estas moviendo el codigo.

Pongo un ejemplo:

Suponiendo que Re evita la clonacion
package coo;

public class Re {

        public Re clone(){
                throw new RuntimeException("Clonacion no soportada");
               
        }
}

Se extiende de Re

Extendiendo e implementando Cloneable
package coo;

public class Re1 extends Re implements Cloneable {
       
        public Re1 clone() {
                 return (Re1) super.clone();
               
        }

}

main
Re1 r = new Re1();
                Re1 r1 = r.clone();
                System.out.println(r);
                System.out.println(r1);

esto nos da como resultado

  Exception in thread "main" java.lang.RuntimeException: Clonacion no soportada
        at coo.Re.clone(Re.java:6)
        at coo.Re1.clone(Re1.java:6)
        at coo.Main.main(Main.java:24)

Bien ahora si tenemos

2da opcion
  public class Re2 extends Re implements Cloneable {
       
        public Re2 clone() {
                Re2 r = new Re2();
               
                //demas cosas aqui
               
                return r;
               
        }

}

main
Re2 r2 = new Re2();
                Re2 r3 = r2.clone();
                System.out.println(r2);
                System.out.println(r3);

Tenemos

main
  coo.Re2@1e311410
  coo.Re2@281c35ec