[JAVA] recuperare valori all'interno di un arraylist con un determinato criterio

[JohnMarston]

Ciao,
dovrei ordinare una lista di oggetti ripetuti in un arraylist.
Ormai sono 3 settimane che ci sto sbattendo la testa, ma non ne vengo a capo. Ho provato in vari modi senza ottenere risultati. Mi chiedevo se qualcuno potesse darmi dei suggerimenti.

La classe di esempio è questa:

public class TestValori {
    
    static double[][] datiA = {
        {-0.10, -0.10, -0.05, -0.05}, {0.05, -0.20, 0.10, -0.15},            
        {-0.10, -0.10, -0.05, -0.05}, {-0.10, -0.10, -0.05, -0.05}, 
        {0.00, -0.20, 0.05, -0.15}, {-0.10, -0.15, -0.05, -0.10}            
    };
    static double[][] datiB = {
        {0.00, -0.15, 0.05, -0.10}, {-0.15, -0.25, -0.10, -0.20}, 
        {-0.10, -0.30, -0.05, -0.25}, {-0.05, -0.15, 0.00, -0.10}, 
        {0.00, -0.15, 0.05, -0.10}, {0.05, -0.15, 0.10, -0.10}             
    };       
    static double[][] datiC = {
        {0.20, 0.00, 0.25, 0.05}, {0.10, 0.00, 0.15, 0.05}, 
        {0.10, -0.15, 0.15, -0.10}, {0.00, -0.10, 0.05, -0.05}, 
        {0.10, -0.10, 0.15, -0.05}, {0.10, -0.10, 0.15, -0.05}             
    };    
    static double[][] datiD = {
        {-0.15, -0.05, -0.10, 0.00}, {-0.05, -0.10, 0.00, -0.05}, 
        {-0.10, -0.20, -0.05, -0.15}, {-0.40, 0.15, -0.35, 0.20}, 
        {-0.20, -0.05, -0.15, 0.00}, {-0.15, -0.10, -0.10, -0.05}             
    }; 
    static double[][] datiE = {
        {0.20, 0.00, 0.25, 0.05}, {0.25, 0.15, 0.30, 0.20}, 
        {0.35, 0.15, 0.40, 0.20}, {0.35, 0.25, 0.40, 0.30}, 
        {0.35, 0.15, 0.40, 0.20}, {0.40, 0.20, 0.45, 0.25}           
    };
    
    //Carico i dati creando l'arrayList
    private static ArrayList creaArrayList(){
        ArrayList globalDati = new ArrayList();
        int totalDati = 5;
        for(int dati=0; dati<totalDati; dati++){
            globalDati.add(new ArrayList());
 
        }
        for(int x=0; x<datiA.length; x++){
            ((ArrayList)globalDati.get(0)).add(new ArrayList());
            ((ArrayList)globalDati.get(1)).add(new ArrayList());
            ((ArrayList)globalDati.get(2)).add(new ArrayList());
            ((ArrayList)globalDati.get(3)).add(new ArrayList());
            ((ArrayList)globalDati.get(4)).add(new ArrayList());

            for(int n=0; n<datiA[x].length; n++){
                ((ArrayList)((ArrayList)globalDati.get(0)).get(x)).add(datiA[x][n]);   
                ((ArrayList)((ArrayList)globalDati.get(1)).get(x)).add(datiB[x][n]);   
                ((ArrayList)((ArrayList)globalDati.get(2)).get(x)).add(datiC[x][n]);   
                ((ArrayList)((ArrayList)globalDati.get(3)).get(x)).add(datiD[x][n]);
                ((ArrayList)((ArrayList)globalDati.get(4)).get(x)).add(datiE[x][n]);
            }
        }
        return globalDati;
    }
    
    //recupera elementi dell'ArrayList
    private static void recuperaElementi(ArrayList globalArray){
        
        int datiTotali = globalArray.size(); //5
        int totaleElementi = ((ArrayList)globalArray.get(0)).size(); //6
        int elementiInterni = ((ArrayList)((ArrayList)globalArray.get(0)).get(0)).size(); //4
        
        for(int dati=0; dati<datiTotali; dati++){
            //lavoro solo su ultimi (datiE)
            if(dati==4){
                System.out.println("Primo ciclo | dati "+dati);
                for(int elementi=0; elementi<totaleElementi; elementi++){                    
                    System.out.println("Primo ciclo | globalArray "+((ArrayList)globalArray.get(dati)).get(elementi));                    
                    
                }
                
            }
            
        }

    }
    
    public static void main(String[] args) {
        recuperaElementi(creaArrayList());
//        System.out.println("ArrayList "+creaArrayList());
    }
}

Questo è l'output che ottengo:

Primo ciclo | dati 4
Primo ciclo | globalArray [0.2, 0.0, 0.25, 0.05] indice 0
Primo ciclo | globalArray [0.25, 0.15, 0.3, 0.2] indice 1
Primo ciclo | globalArray [0.35, 0.15, 0.4, 0.2] indice 2
Primo ciclo | globalArray [0.35, 0.25, 0.4, 0.3] indice 3
Primo ciclo | globalArray [0.35, 0.15, 0.4, 0.2] indice 4
Primo ciclo | globalArray [0.4, 0.2, 0.45, 0.25] indice 5

Io devo recuperare gli elementi con indice 0, 1, 2 e 5 e salvarli in un altro ArrayList.

Come potete notare l'indice 2,3,4 hanno il primo elemento uguale (0.35), mentre il secondo no.

Primo ciclo | globalArray [0.35, 0.15, 0.4, 0.2] indice 2
Primo ciclo | globalArray [0.35, 0.25, 0.4, 0.3] indice 3
Primo ciclo | globalArray [0.35, 0.15, 0.4, 0.2] indice 4

Perché devo recuperare solo i valori dell'indice 2?
Perché l'indice 2 e 4 sono uguali, quindi ne devo prendere solo uno dei due e il secondo elemento dell'indice 2 e 4 è inferiore al secondo dell'indice 3 (0.15<0.25).

Come posso fare?
Oltre a questo è possibile contare quante volte gli stessi elementi vengono ripetuti? È un dato che volevo salvarlo...

Grazie