Primi programmi - array

di il
7 risposte

Primi programmi - array

Ciao a tutti,
da pochissimo sto cominciando a studiare un po' di programmazione Java ma ho dei problemi a capire come organizzare i programmi (anche se molto semplici) perché essendo abituata al C sto perdendo un po'di tempo ad abituarmi all'organizzazione "a oggetti".

Per esempio, mettiamo che io voglia risolvere un esercizio che dice di creare un array di al max 100 elementi che sia una lista ordinata di numeri e che abbia tre metodi:
print(), che stampa la lista;
add(int) e add(int[]) che aggiungono un numero o una lista di numeri all'array.

Il mio problema non è tanto scrivere i metodi, ma capire "dove" scriverli.
Devo creare una classe per l'array che contiene i metodi e una classe col main per runnare e "provare" il programma?

Qualcuno può darmi una mano? Mi servirebbe uno scheletro con classi e le intestazioni dei metodi, giusto per capire.
Grazie.

7 Risposte

  • Re: Primi programmi - array

    eclipto ha scritto:


    Per esempio, mettiamo che io voglia risolvere un esercizio che dice di creare un array di al max 100 elementi che sia una lista ordinata di numeri e che abbia tre metodi:
    print(), che stampa la lista;
    add(int) e add(int[]) che aggiungono un numero o una lista di numeri all'array.
    Domande (su cose che non hai precisato). L'array deve essere istanziato fisso a 100 elementi di capacità e devi gestire tu il numero "logico" di elementi? Oppure devi ricrearlo più capiente man mano che aggiungi elementi (considerando comunque quel limite di 100)?

    In entrambi i casi e visto che parli di "lista ordinata di numeri" (che presuppone una logica interna per mantenere ordinata la sequenza), allora HA SENSO incapsulare tutta la logica e la gestione in una classe apposita.

    eclipto ha scritto:


    Il mio problema non è tanto scrivere i metodi, ma capire "dove" scriverli.
    Devo creare una classe per l'array che contiene i metodi e una classe col main per runnare e "provare" il programma?
    Ipotizziamo allora una classe dedicata a questo es. ArrayOrdinato (o in inglese SortedArray, come preferisci)

    Il main lo potrai mettere in un'altra classe più consona a testare/utilizzare la classe che ho appena indicato.
  • Re: Primi programmi - array

    Questo è un gestore di array di interi in Java. Il costruttore prende in pasto un array di interi e la classe fornisce i metodi, copyof, indexof, concat, concatNodup, replace. L'ho trovato all'inizio un ottimo esercizio per prendere dimestichezza con Java e spero che ti possa essere utile.
    L'OOP differisce dal paradigma del C. https://it.wikipedia.org/wiki/Programmazione_orientata_agli_oggetti
    
    public class GestoreArray {
    
    	private int[] a;
    	
    	public GestoreArray(int[] a){this.a=a;}
    	
    	private int[] copyOf(int[] a, int i){
    		int[] b = new int[a.length+i];
    		
    		for(int x=0; x<a.length; x++){
    			if(i<0 && x==b.length) break;
    			b[x] = a[x];
    		}
    		return b;
    	}
    	
    	public int indexOf(int x){
    		if(a!=null && a.length>0){
    			for(int i=0; i<a.length ; i++){
    				if(x == a[i]) return i;
    			}
    		}
    		return -1;
    	}
    	
    	public void concat(int[] i){
    		if( i!= null && i.length>0 && a!=null && a.length>0){
    			int t = a.length;
    			this.a = copyOf(this.a, i.length);
    			for(int x=0; x<i.length; x++){
    				this.a[t+x] = i[x];
    			}
    		}
    	}
    	
    	public int concatNoDup(int[] i){
    		int c=0;
    		if( i!= null && i.length>0 && a!=null && a.length>0){
    			for(int x=0 ; x<i.length; x++){
    				if(!replace(i[x], i[x])){
    					a = copyOf(a,1);
    					a[a.length-1] = i[x];
    					c++;
    				}
    			}		
    		}
    		return c;
    	}
    	
    	
    	public boolean replace(int x, int y){
    		for(int i=0; i<a.length; i++){
    			if(a[i] == x) { a[i] = y; return true;}
    		}
    		return false;
    	}
    	
    	
    }
    
    
  • Re: Primi programmi - array

    Innanzitutto grazie a entrambi.

    Posto il codice funzionante che ho scritto (qualunque commento è ben accetto).

    Questa è la classe della lista ordinata:
    
    package ArrayEx;
    
    public class SortedArray {
    	
    	private int[] myarray = new int[100];
    	
    	public SortedArray(int[] myarray) {
    		this.myarray = myarray;
    		sort();
    	}
    	
    	public void print(){
    		for(int i:myarray){
    			System.out.println(i);
    		}
    	}
    	
    	private void sort(){
    		for(int i = 0; i < myarray.length; i++){
    			for(int j = 0; j < myarray.length-1; j++){
    				if(myarray[j] > myarray[j+1]){
    					int tmp = myarray[j+1];
    					myarray[j+1] = myarray[j];
    					myarray[j] = tmp;
    				}
    			}
    		}
    	}
    	
    	private int getMaxIndex(){
    		int max = myarray[0], index = 0;
    		
    		for(int i = 0; i < myarray.length; i++){
    			if(myarray[i] > max){
    				max = myarray[i];
    				index = i;
    			}
    		}
    		return index;
    	}
    	
    	public void add(int a){
    		int index = getMaxIndex();
    		myarray[index] = a;
    		sort();
    	}
    	
    	public void add(int[] a){
    		for(int z:a){
    			int index = getMaxIndex();
    			myarray[index] = z;
    		}
    		sort();
    	}
    }
    
    Questo è il main per testare il tutto:
    
    package ArrayEx;
    
    import java.util.Random;
    
    public class arrayApp {
    
    	public static void main(String[] args) {
    		
    		int[] array = new int[100];
    		
    		for(int i = 0; i < array.length; i++){
    			Random rn = new Random();
    			array[i] = rn.nextInt(200);
    		}
    		
    		SortedArray mylist = new SortedArray(array);
    		
    		mylist.print();
    
    		int[] a = {1, 3, 7, 2, 8, 11, 0};
    		
    		//int x = 1;
    		mylist.add(a);
    		mylist.print();
    	}
    }
    
    Rispondo alle domande e poi vi pongo le mie.

    andbin ha scritto:


    Domande (su cose che non hai precisato). L'array deve essere istanziato fisso a 100 elementi di capacità e devi gestire tu il numero "logico" di elementi? Oppure devi ricrearlo più capiente man mano che aggiungi elementi (considerando comunque quel limite di 100)?
    Non è specificato. Io l'ho istanziato fisso (se ho capito bene quello che intendi). Cosa avrei dovuto fare negli altri casi?

    Per il resto vorrei chiedervi:
    - Innanzitutto, il codice "ha senso", sia da un punto di vista di quello che fa che della struttura che ha?
    - Le due classi private, quelle che fanno il sort e trovano l'indice del max, dovrebbero essere dichiarate static? Non credo di aver ben capito cos'è e cosa fa un metodo (o un attributo) static.

    Grazie mille a entrambi, siete stati chiarissimi e utili
  • Re: Primi programmi - array

    eclipto ha scritto:


    Non è specificato. Io l'ho istanziato fisso (se ho capito bene quello che intendi). Cosa avrei dovuto fare negli altri casi?
    Nel primo caso che ho detto (che hai più o meno fatto tu), si istanzia l'array con una capacità maggiore (nel tuo caso il limite è fisso/noto) e poi si dovrebbe tenere a parte il numero "logico" di elementi.
    Nel secondo caso che ho detto, si parte con un array di capacità 0, poi ad ogni inserimento si istanzia un nuovo array della giusta capacità, si ricopiano gli elementi dal vecchio array e si aggiungono gli elementi aggiunti. Il vecchio array lo si "butta" via nel senso che non sarà più referenziato. In questo caso il numero logico di elementi è la capacità fisica dell'array.

    Queste in sostanza sono le due tecniche per gestire una "lista espandibile" basata su array. La prima è più efficiente/furba della seconda.

    eclipto ha scritto:


    - Innanzitutto, il codice "ha senso", sia da un punto di vista di quello che fa che della struttura che ha?
    Tecnicamente può anche funzionare (non ho provato il tuo codice) ma è comunque poco furbo e molto inefficiente. Parlo del fatto che ad ogni inserimento rifai un sort completo.

    Quando una sequenza è da mantenere ordinata per contenuto, generalmente l'obiettivo è quello di trovare velocemente il punto giusto di inserimento affinché la lista sia e resti ordinata. La ricerca del punto di inserimento si può fare in due modi:
    - con ricerca lineare (poco efficiente)
    - con l'algoritmo del "binary search" (più furbo ed efficiente)

    eclipto ha scritto:


    - Le due classi private, quelle che fanno il sort e trovano l'indice del max, dovrebbero essere dichiarate static? Non credo di aver ben capito cos'è e cosa fa un metodo (o un attributo) static.
    Non hai classi "innestate". Hai solo metodi lì. E siccome in SortedArray tutti i metodi operano in funzione della variabile di istanza myarray, allora NESSUNO di quei metodi fatti ha senso che sia "di classe", ovvero static.
  • Re: Primi programmi - array

    Ah, ti segnalo anche che qui:
          for(int i = 0; i < array.length; i++){
             Random rn = new Random();
             array[i] = rn.nextInt(200);
          }
    l'oggetto Random sarebbe meglio istanziarlo una volta sola, prima del for.
  • Re: Primi programmi - array

    andbin ha scritto:


    Quando una sequenza è da mantenere ordinata per contenuto, generalmente l'obiettivo è quello di trovare velocemente il punto giusto di inserimento affinché la lista sia e resti ordinata. La ricerca del punto di inserimento si può fare in due modi:
    - con ricerca lineare (poco efficiente)
    - con l'algoritmo del "binary search" (più furbo ed efficiente)
    Hai ragione.

    Avevo inizialmente scritto un metodo che cercava (linearmente) il punto in cui inserire ogni elemento e faceva "scivolare giù" tutti gli altri (sbarazzandosi del massimo, che era alla fine).

    Poi per qualche motivo mi è sembravo più furbo questo metodo perché fa una sola volta il sort inserendo un array non ordinato; ma in realtà non ha alcun senso, visto che comunque ogni volta fa una ricerca lineare per cercare il massimo. Tra l'altro, visto che "per costruzione" il massimo è alla fine, il tutto ha ancora meno senso.
    Inoltre non mi sono occupata dell'efficienza degli algoritmi di ricerca e ordinamento perché stavo cercando di capire altro, ma hai ragione. Mi sa che, effettivamente, è ora che io a fare gli ex con algoritmi efficienti, così alla lunga mi verranno "automatici" (si spera).

    Ti chiedo: come si potrebbe risolvere il tutto in modo "più furbo"?
    Nel caso di un intero cerco il punto di inserzione e faccio "scivolare" il resto? E nel caso di un array supposto non ordinato? Faccio la stessa cosa per tutti gli elementi?

    Grazie ancora.
  • Re: Primi programmi - array

    eclipto ha scritto:


    Ti chiedo: come si potrebbe risolvere il tutto in modo "più furbo"?
    Nel caso di un intero cerco il punto di inserzione e faccio "scivolare" il resto? E nel caso di un array supposto non ordinato? Faccio la stessa cosa per tutti gli elementi?
    Puoi sicuramente fare il add singolo implementato con il binary search (che non è difficile, te lo assicuro) e una volta trovato il punto di inserimento, a) sposti in avanti gli elementi dal quel punto e b) setti in quel punto l'elemento da inserire. Poi puoi implementare il add multiplo in funzione del add singolo.

    E il costruttore lo puoi implementare in funzione del add multiplo. Tieni presente che come avevi fatto prima non era molto buono. Intendo il fatto che il costruttore riceveva un array (potenzialmente non ordinato) e poi lo assegnavi direttamente al campo myarray. Ma questo vuol dire che il vincolo dei max 100 elementi non era garantito né gestito. Se al costruttore passavi un array di 200 elementi, la tua classe continuava ad usare quello. Oltre al fatto che andavi a modificare con il sort un array di cui SortedArray non ha (e non dovrebbe) avere controllo poiché passato da qualcun'altro.
Devi accedere o registrarti per scrivere nel forum
7 risposte