Visualizzazione dei risultati da 1 a 10 su 10
  1. #1

    [Java] Ordinare Matrice - Parere/Aiuto

    Salve a Tutti

    Avendo una matrice dati tipo String[x][2]
    dove i valori sono tipo:
    codice:
    mat[0][0]= "100/20/AB"
    mat[0][1]= "descrizione testuale"
    --------------------------------------
    mat[1][0]= "800/01/DF"
    mat[1][1]= "descrizione testuale"
    --------------------------------------
    mat[2][0]= "1200/10/AB"
    mat[2][1]= "descrizione testuale"
    --------------------------------------
    mat[3][0]= "800/20/AB"
    mat[3][1]= "descrizione testuale"
    --------------------------------------
    ......... n volte
    --------------------------------------
    mat[n][0]= "900/05/DF"
    mat[n][1]= "descrizione testuale"
    --------------------------------------
    Vorrei ordinare la matrice in base al primo array,
    ovvero ai valori alfanumerici del tipo 1200/10/AB
    e precisamente in ordine crescente prima in base alla prima
    parte che nel tipo di esempio appena fatto è 1200
    dopo in base al secondo valore che nell'esempio è 10
    ed infine in base alla parte letterale che nell'esempio è AB.

    Devo ancora scrivere il codice e visto che non esiste una Classe specifica
    per ordinare le matrici, avevo pensato di estrarre dalla matrice il primo
    array e da questo ricavarne altri tre (splittando tramite "\") che mi contengano
    ognuno le tre parti da ordinare, creare l'algoritmo per ordinarli in successione
    e riassemblare poi il tutto in una nuova matrice.

    Spero di aver spiegato il tutto bene..... cosa ne pensate,
    è il metodo più giusto?
    Esistono altri metodi migliori?

    Grazie, a presto

  2. #2
    Utente di HTML.it
    Registrato dal
    Aug 2002
    Messaggi
    8,013
    una mappa ordinata? tipo TreeMap
    <´¯)(¯`¤._)(¯`»ANDREA«´¯)(_.¤´¯)(¯`>
    "The answer to your question is: welcome to tomorrow"

  3. #3
    Moderatore di Programmazione L'avatar di LeleFT
    Registrato dal
    Jun 2003
    Messaggi
    17,320
    Secondo me, se i valori sono scritti nel modo che hai specificato, ovvero per la parte centrale i numeri sono scritti con eventuale padding di zeri davanti, è sufficiente l'ordinamento lessicografico dato dalla stringa nel suo complesso.

    Le stringhe, infatti, vengono ordinate in modo lessicografico partendo da sinistra. Quindi, la stringa "800/01/DF" viene prima della stringa "800/20/AB" poichè lo "0" dopo lo slash nella prima ha valore inferiore rispetto al "2" dopo lo slash nella seconda. Quindi, se il formato è esattamente quello, l'unica parte da valutare in modo numerico è la prima, ricavabile facilmente in questo modo:

    codice:
    int pos = mat[x][0].indexOf('/');
    String primaParte = mat[x][0].substring(0, pos);
    int valoreNumerico = Integer.parseInt( primaParte );
    Ciao.
    "Perchè spendere anche solo 5 dollari per un S.O., quando posso averne uno gratis e spendere quei 5 dollari per 5 bottiglie di birra?" [Jon "maddog" Hall]
    Fatti non foste a viver come bruti, ma per seguir virtute e canoscenza

  4. #4
    Innanzi tutto grazie per l'attenzione.

    Dunque, andiamo con ordine....

    Punto uno, per il metodo TreeMap che suggerisce Andrea
    non saprei, non conosco TreeMap.
    Sono andato a leggermi qualcosa velocemente
    e sembra un buon metodo, cioè una volta messi
    i codici come chiave e le descrizioni come valore
    del TreeMap, dovrebbe essere semplice ordinarlo
    se esiste un metodo per farlo in base alla chiave!! ... ?
    Se non fosse così ci ritroviamo al punto due.....

    Punto due.... Lele hai capito bene come sono strutturati
    i valori, cioè con il padding di zeri, ma solo per la seconda
    parte; quindi una volta ricavato l'array con la sola parte
    iniziale dei codici dovrei ordinare solo questo e poi ricostruire
    il tutto.... ma come!?

    Mi chiedo...
    supponiamo di avere questi codici:
    1) 100/01/OP
    2) 200/15/EP
    3) 100/20/ED
    4) 100/12/ED
    5) 200/01/UT

    ... se estraggo la prima parte del codice avrò valori uguali
    nei punti 1-3-4 e 2-5....
    1) 100
    2) 200
    3) 100
    4) 100
    5) 200

    che non possono essere ordinati, o meglio possono, ma poi ho
    bisogno della seconda parte per ottenere un ulteriore ordine....

    1) 100/01/OP
    2) 100/12/ED
    3) 100/20/ED
    4) 200/01/UT
    5) 200/15/EP

    e così per la parte letterale!!

  5. #5
    Moderatore di Programmazione L'avatar di LeleFT
    Registrato dal
    Jun 2003
    Messaggi
    17,320
    Supponendo di avere un oggetto Codice (non so, immagino sia un codice quella stringa) che rappresenta la stringa della posizione 0 nella matrice, è sufficiente farle implementare Comparable per ottenere l'ordinamento che ti serve (e usare, quindi, anche un TreeMap o un TreeSet, come suggerito da Andrea):

    codice:
    public class Codice implements Comparable<Codice> {
       private String strCodice;   // Conterrà, ad esempio "100/20/ED"
    
       public Codice(String strCodice) {
          this.strCodice;
       }
    
       ...   // Getter e Setter
    
       // Ricava il valore numerico della prima parte della stringa
       private int valoreNumerico(String str) {
          int pos = str.indexOf('/');
          String primaParte = str.substring(0, pos);
          return Integer.parseInt( primaParte );
       }
    
       // Ricava la seconda parte della stringa (dopo il primo '/')
       private String secondaParte(String str) {
          return str.substring( str.indexOf('/') );
       }
    
       @Override
       public int compareTo(Codice c) {
          int val1 = valoreNumerico( strCodice );
          int val2 = valoreNumerico( c.strCodice );
          int ret = val1 - val2;
          if (ret == 0) {
             ret = secondaParte( strCodice ).compareTo( secondaParte(c.strCodice) );
          }
          return ret;
       }
    }
    Il procedimento è semplice: date 2 stringhe contenenti ciascuna un codice, confronto il valore numerico della prima parte di ciascuna di esse. Se sono diverse, restituisco la differenza fra le tue, se sono uguali, restituisco il confronto fra le due parti di stringa rimanenti.

    Oggetti di tipo Codice, a questo punto, possono essere ordinate facilmente mediante l'uso di Arrays.sort() o Collections.sort() e possono essere usate all'interno di collezioni pre-ordinate come TreeSet o TreeMap.


    Ciao.
    "Perchè spendere anche solo 5 dollari per un S.O., quando posso averne uno gratis e spendere quei 5 dollari per 5 bottiglie di birra?" [Jon "maddog" Hall]
    Fatti non foste a viver come bruti, ma per seguir virtute e canoscenza

  6. #6
    Grazie Lele.... ma non riesco a comprendere come funzionerebbe il codice!

    Ho una Classe Codici() che istanzio con l'oggetto codici:
    Codici codici = new Codici();
    In questa classe ho i metodi per leggere i codici da DB
    visualizzarli in una JDialog da dove è possibile modificarli,
    cancellarli e aggiungerne altri, oltre che ad altri metodi set e
    get. Nell'aggiungere o modificare i codici ho esigenza di riordinarli
    in maniera decrescente e per questo, quando il JDialog rimanda la
    matrice dei codici all'oggetto codici questa matrice viene passata
    ad una Classe che provvede a riordinarli e restituire una nuova matrice
    con i codici ordinati....
    String[][] newCods = new OrdinaCodici(matCods);

    Come imposteresti la Classe OrdinaCodici ?!

    Io sto provando, estrapolando dalla matrice il primo array
    contenente i codici (non le descrizioni), questo lo divido
    ulteriormente in altri tre array contenenti le tre parti del
    codice, per poi ordinarli. Credo che il difficile sia poi trovare
    le corrispondenze degli indici per ricomporre in un'unico array
    i tre array contenenti le parti dei codici!!!

  7. #7
    Utente di HTML.it
    Registrato dal
    Aug 2002
    Messaggi
    8,013
    avevo del codice già scritto, quindi ho aggiunto roba e cancellato l'inutile/superfluo. Mi scuso per l'eventuale cattivo stile di programmazione risultante

    codice:
    import java.util.*;
    /**
     *
     * @author Andrea
     */
    public class Esercizio45 {
            
        private class MyComparator implements Comparator<String> {
            
            public int compare(String s1, String s2) {
                String[] split_1 = s1.split("/");
                String[] split_2 = s2.split("/");
                
                Integer i1_1 = Integer.parseInt(split_1[0]);
                Integer i1_2 = Integer.parseInt(split_1[1]);
                
                Integer i2_1 = Integer.parseInt(split_2[0]);
                Integer i2_2 = Integer.parseInt(split_2[1]);
                
                if (i1_1.compareTo(i2_1) == 0) {
                    if (i1_2.compareTo(i2_2) == 0) {
                        return split_1[2].compareTo(split_2[2]);
                    }
                    else {
                        return i1_2.compareTo(i2_2);
                    }
                }
                else {
                    return i1_1.compareTo(i2_1);
                }                    
            }
        }
        
        String[][] matrix = new String[][] {
            {"100/20/AB","cento venti alpha bravo"},
            {"800/01/DF", "ottocento uno delta foxtrot"},
            {"1200/10/AB", "milleduecento dieci alpha bravo"},
            {"800/20/AB", "ottocento venti alpha bravo"},
            {"100/20/DF", "cento venti delta foxtrot"},
            {"900/05/DF", "novecento cinque delta foxtrot"}
        };
        
        TreeMap<String, String> map = new TreeMap<String, String>(new MyComparator());
        
        public void makeTree() {
            for (int i = 0; i < matrix.length; i++) {
                map.put(matrix[i][0], matrix[i][1]);
            }
        }
        
        public String[][] orderedMatrix() {
            Set<String> set = map.keySet();
            String[][] temp = new String[matrix.length][matrix[0].length];
            Iterator<String> iterator = set.iterator();
            int i = 0;
            while (iterator.hasNext()) {
                String elem = iterator.next();
                temp[i][0] = elem;
                temp[i][1] = map.get(elem);
                i++;
            }
            return temp;
        }
        
        public static void main (String[] args) {
            Esercizio45 e = new Esercizio45();
            e.makeTree();
            String[][] ordered = e.orderedMatrix();
            for (int i = 0; i < ordered.length; i++) {
                System.out.println(ordered[i][0]+"  -->  "+ ordered[i][1]);
            }
        }
        
    }
    Raccomandazione: un TreeMap non prevede che vi possano essere chiavi identiche. Non so se sia il tuo caso, però potresti voler aggiungere della logica ulteriore per gestire l'eventuale caso.
    <´¯)(¯`¤._)(¯`»ANDREA«´¯)(_.¤´¯)(¯`>
    "The answer to your question is: welcome to tomorrow"

  8. #8
    .....
    Raccomandazione: un TreeMap non prevede che vi possano essere chiavi identiche. Non so se sia il tuo caso, però potresti voler aggiungere della logica ulteriore per gestire l'eventuale caso.
    Infatti è il mio caso
    Lo stavo giusto sperimentando scrivendo la Classe che spiegavo nel post sopra,
    ti lascio il codice così vedete:
    codice:
    import java.util.TreeMap;
    
    public class OrdinaCodici {
    
    	public OrdinaCodici(String[][] matCods) {
    		System.err.println("\n\t******!! OrdinaCodici().line6: ORDINARE MATRICE!!!!!!!!!!!!!!");
    		
    		int length = matCods.length;
    		
    		String[] arrayUno = new String[length];
    		String[] arrayDue = new String[length];
    		String[] arrayTre = new String[length];
    		TreeMap<String, Integer> mappa = new TreeMap<String, Integer>();
    		
    		for (int x=0; x<length; x++) {
    			
    			System.out.println("___________________________________________________________________________\n"+
    								"matcCods["+x+"][0]: "+matCods[x][0]+"\tmatcCods["+x+"][1]: "+matCods[x][1]);
    			
    			String[] tempArray = matCods[x][0].split("/");
    			arrayUno[x] = tempArray[0];
    			arrayDue[x] = tempArray[1];
    			arrayTre[x] = tempArray[2];
    			
    			System.out.println("arrayUno["+x+"]: "+arrayUno[x]+"\tarrayDue["+x+"]: "+arrayDue[x]+"\tarrayTre["+x+"]: "+arrayTre[x]+"\n");
    			
    			mappa.put(arrayUno[x], x);
    						
    			System.out.println("mappa.get(arrayUno["+x+"]): "+mappa.get(arrayUno[x]));
    		}
    		
    		System.out.println("\n===================================================================="+
    							"\nmappa.values(): "+mappa.values()+"\tmappa.size(): "+mappa.size());
    		
    		System.out.println("\nmappa.toString(): "+mappa.toString());		
    		
    	} // FCOS
    } // FC
    Mi scuso per la formattazione ma è workInProgress!!
    Per verificarne il funzionamento puoi inviarli la tua matrice "matrix".
    E ho notato che le parti di codici identiche non vengono riportate più
    di una volta e per quello che intendevo far io non va bene

    L'idea era quella di inserire come key la prima parte dei codici e come value l'indice
    dell'array che le contiene. Così creare altri due TreeMap per le seconde parti dei
    codici e le terze parti. Poi, ordinati i TreeMap avrei trovato il modo, in base all'ordine
    dei value e quindi degli indici degli array di ricostruire la matrice ordinata!!
    Non so se si è capito il mio procedimento!

    Proverò intanto il tuo codice.

  9. #9
    Ho provato il tuo codice ... funziona bene, alla grande

    Ora devo solo studiarlo per capirne il funzionamento.

    Grazie infinite

  10. #10
    Ci sono cose che ancora non conosco bene,
    come Comparator, Set e Iterator, chiaramente
    dovrò approfondire.

    Ma potresti per cortesia spiegarmi il funzionamento
    del tuo codice, cioè passo passo cosa fa.

    Te ne sono grato, ciao

Permessi di invio

  • Non puoi inserire discussioni
  • Non puoi inserire repliche
  • Non puoi inserire allegati
  • Non puoi modificare i tuoi messaggi
  •  
Powered by vBulletin® Version 4.2.1
Copyright © 2025 vBulletin Solutions, Inc. All rights reserved.