style="display:inline-block;width:728px;height:90px"
data-ad-client="ca-pub-5164839828746352"
data-ad-slot="7563230308">

Mantener valore de un ArrayList despues de mandar su contenido a un metodo

Buenas tardes, días o noches a todos los del foro.

tengo un problema resulta que tengo un ArrayList<String> datos = new Arraylist<>()
que se llena dinámicamente dependiendo de los movimientos a realizar.. hasta todo bien

ahora con esos datos necesito hacer otras operaciones
asi que la mando a otro metodo o funcion

private void btnAceptarActionPerformed(java.awt.event.ActionEvent evt) {
    ArrayList<String> datos = new Arraylist<>()
    ArrayList<String> estructurado = new Arraylist<>()
    ArrayList<String> historiales = new Arraylist<>()
    //supongamos que el array datos tiene los siguientes numeros 1,4,7,9,10

    //todo ese contenido lo voy a mandar a mi método
    estructurado = restructurar(datos);
    //pero después de volver a mandar el contenido de array list datos
    // como que si el arralist se vaciara se queda sin elementos.. hay alguna manera de que esto no sucesa
    historiales = historial_registro(datos);
}

public ArrayList<String> restructurar(ArrayList<String> datos){
    ArrayList<String> prepatado = new ArrayList<>();
    try {
         Vector<String> datosGuardar = new Vector(1);
         int cont = 0;
         Iterator<String> nombreIterator = datos.iterator();
         while (nombreIterator.hasNext()) {
             if (cont <= 0){
                    String elemento = nombreIterator.next();
                    datosGuardar.addElement(elemento);
                    datosGuardar.addElement("3");
                    nombreIterator.remove();
              }
              if (cont == 0){
                    preparado.add(datosGuardar.get(0));
                    preparado.add(datosGuardar.get(1));
                    datosGuardar.removeAllElements();
                    cont = -1;
                }
                cont++;
            }
    } cacth(Exception e) {
        System.out.println(e)
    }
    return nueva_estructura;
}
//-------------------------------------------------------------------------------------------------------------------

public ArrayList<String> historial_registro(ArrayList<String> datos){
ArrayList<String> objetos = new ArrayList<>();
try{
 Vector<String> datosGuardar = new Vector(1);
            int cont = 0;
            Iterator<String> nombreIterator = datos.iterator();
            while (nombreIterator.hasNext()) {
                if (cont <= 0){

                    nombreIterator.remove();
                }
                if (cont == 0){

                    cont = -1;
                }
                cont++;
            }
    } cacth(Exception e){
        System.out.println(e)
    }
    return objetos;
}

hay alguna manera que no se pidan los datos del ArrayList original bueno lo que pasa es que para salir momentáneamente del problema
hice varias copias del array original

espero que me echen la mano a lo mejor lo he declarado mal

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 adrianaaae

No es que se vacie

Bueno entendiendo un poco tu problema dices que cada vez que apretas el boton hacer tu proceso pero cuando vuelves a apretar tu boton el array se vacia???
Si es así es por que esta dentro del evento del boton; es decir que cada vez que das click al boton se declara de nuevo tu array y obviamente es vacio al declararlo.
Para que mantenga los valores tiene que estar declarado de manera Global así no pieden su contenido.

Imagen de pechsclk

declarado de manera Global

no es que primero ejecute una y luego otra vez el botón,

es dentro del cuerpo del botón están esas dos métodos
pero el primer ArrayList lo recibe desde el exterior, proviene de una ventana anterior

ArrayList<String> estructurado = new ArrayList<>(); // esto lo recibe de la ventana anterior
ArrayList<String> historiales = new ArrayList<>();
//supongamos que que ArrayList datos tiene los numero de registros, que puede ser 30,120,864,1099
//estos datos datos necesito obtener otros así que lo paso al método que es restructurar(datos)
estructurado = restructurar(datos); //hasta aquí todo bien
// pero esos valores anteriores o originales del array list datos necesito hacer otras operaciones asi que la mando al siguiente metodo que es historial_registro(datos)  pero as de cuenta que como que se limpia o se bacia el valor de array datos al momento de pasarlo por parametro en el metodo.... asi que en el segundo metodo no hace nada porque los datos llegan bacios
historiales = historial_registro(datos);
 

Cuando llamas a

Cuando llamas a iterator.remove() estás quitando elementos de la colección de donde lo obtuviste.

Supongo que esta línea no existe en tú código:

    ArrayList<String> datos = new Arraylist<>()

Por que si es así, en realidad tu lista siempre esta vacía, pero ok, suponiendo que no existe, entonces al llamar:

Iterator<String> i = datos.iterator();

while( i.hasNext()  ) {
     ...
     i.remove();
}

Estás eliminando los datos de la lista. Para que no removerlos quita el i.remove();

Tu código tiene otros problemas, número uno, no compila ( supongo que lo escribiste de nuevo en el post por ejemplo dice cacth )
Si es así intenta hacer un programa chiquito donde puedas reproducir el problema y pon ese, por ejemplo algo como:

import java.util.List;
import java.util.ArrayList;
import java.util.Iterator;

class Main {
    public static void main( String ... args ) {
        List<String> lista = new ArrayList<>();
        lista.add( "1" );
        lista.add( "2" );
        lista.add( "3" );
        List<String> resultado = reestructura( lista );
        System.out.println(lista);
    }
    public static List<String> reestructura( List<String> lista ) {
          Iterator<String> it = lista.iterator();
          List<String> resultado = new ArrayList<>();
          while( it.hasNext() ) {
               resultado.add( it.next() );
               it.remove();
          }
          return resultado;
    }
}

Así es probable que tu mismo des con la respuesta y si no, alguien que no tiene ( ni quiere tener ) todo tu código puede entender qué está pasando.

Otra cosa, en java se utiliza camelCase para los nombres, ( clases empiezan con mayúsculas, métodos y variables con minúsculas ) en vez de nombres_con_underscore Quizá tu lo encuentres más legible, pero es una convención que se utiliza en todo el lenguaje y es mejor seguirla.

Extra, utiliza

List<String> a = new ArrayList<>();

en vez de

ArrayList<String> a = new ArrayList<>();

para que le programes a la interfaz

datos, estructurado e historiales

 

Sólo por curiosidad, ¿cuál es la diferencia entre datos, estructurado e historiales?

Por cierto, puedes obtener una vista de sólo lectura de tu lista de la siguiente manera:

List<String> list = new ArrayList<>();
list.add("1");
...
// Read-only list
List<String> unmodifiableList = Collections.unmodifiableList(list);

Cualquier modificación sobre esta lista (p.ej.: unmodifiableList.add("2");), arrojará java.lang.UnsupportedOperationException.

~~~

Imagen de pechsclk

Por cierto, puedes obtener

bueno aquí esta esta el dato real

bueno aqui esta el daato real, ya sabes trabajo bajo rmi

EMO-2015-1532 CAFETERA DE PERCOLA CTS-93 LG CT-2863W NEGRO
EMO-2015-1534 CAJA DE DINERO CT-29488 DINAMO CT-2948 BLANCO

yo realizo el movimiento de activos y los preparo para poder realizar el movimiento pero al hacer el movimiento no guardo todos esos datos si no los ids
y este movimiento lo registro en una tabla de historiales pero este dato el
realidad lo obtengo son los numero de registro de los emos, y de estos datos
1393
1395
estos datos son los almacenados en el primer arraylist tipo llamaremos dat_mov

objRemoto.registrar_mov_de_cambios_activo( dat_mov) // registra un movimiento
estructura = estructurar_registro_historial(dat_mov); // como se darán cuenta este hace un llamado al método que esta mas abajo; la variable estructura es de tipo ArrayList
objRemoto.registrar_historial_activo(estructura);//registra el historial activo
// pero si se da cuenta dat_mov que contiene los números 1393,1395 al momento de pasa al método estructurar_registro_historial como que se limpia;
El mismo arrayList original dat_mov ese dato lo ocupo para hacer un registro en otra tabla pero ya no logro registrar porque dat_mov, ya viene bacio, y da el error por las llaves poranes

objRemoto.registrar_detalle_responsiva(dat_mov, num_regresp2, "ACTIVO");
// estos datos o las llamas estan dentro de un boton

public ArrayList<String> estructurar_registro_historial(ArrayList<String> num_asig) {
        ArrayList<String> estructura = new ArrayList<>();
        try {
            Vector<String> datosGuardar = new Vector(1);
            int cont = 0;
            Iterator<String> nombreIterator = num_asig.iterator();
            while (nombreIterator.hasNext()) {
                if (cont <= 0) {
                    String elemento = nombreIterator.next();
                    datosGuardar.addElement(elemento);
                    datosGuardar.addElement(num_sucdepto);
                    datosGuardar.addElement(txtNumpersonal.getText());
                    datosGuardar.addElement(txtMotivo.getText());
                    datosGuardar.addElement(fechaActual);
                    datosGuardar.addElement("2");
                    nombreIterator.remove();
                }
                if (cont == 0) {
                    estructura.add(datosGuardar.get(0));
                    estructura.add(datosGuardar.get(1));
                    estructura.add(datosGuardar.get(2));
                    estructura.add(datosGuardar.get(3));
                    estructura.add(datosGuardar.get(4));
                    estructura.add(datosGuardar.get(5));
                    datosGuardar.removeAllElements();
                    cont = -1;
                }
                cont++;
            }
        } catch (Exception e) {
            System.out.println(e);
        }
        return estructura;
    }

 Una solución rápida sería

 

Una solución rápida sería cambiar esta línea:

estructura = estructurar_registro_historial(dat_mov);

por:

estructura = estructurar_registro_historial(new ArrayList<>(dat_mov));

Sin embargo, esta solución no es la mejor. El código necesita ser refactorizado, tal como Oscar ya lo sugirió.

~~~

Imagen de ezamudio

Listas mutables

Este es un error muy común al usar colecciones mutables. ArrayList es una lista mutable; si el dueño de la lista quiere pasarla a otros objetos pero que no se la modifiquen, hay dos opciones: Pasar a los demás una copia inmutable (con Collections.immutableList(lista)) o bien, crear una nueva lista con los mismos elementos, para que si la modifican, no se afecte la lista original.

La primera opción es mucho más eficiente. Pero si otro objeto recibe una lista y debe modificarla, debe crear una copia local y esa es la que debe modificar.

Imagen de pechsclk

la primera opcion es más eficiente

Como lo copio de la lista Inmutable del ArrayList a la
Collections.immutableList(lista)

termine poniendo de esta forma como dijo JPaul anque no es lo correcto

estructura = estructurar_registro_historial(new ArrayList<>(dat_mov));

esto lo hice para nomas salir del paso por el momento
de antenano gracias por sus comentarios

style="display:inline-block;width:728px;height:90px"
data-ad-client="ca-pub-5164839828746352"
data-ad-slot="7563230308">