[Java] Problema creazione classe per gestione array di interi

[D4rkAng3l]

Ciao,
allora sulle dispense della mia professoressa ci stà l'implementazione di una classe che serve come contenitore utile di metodi di utilità su array di interi...in fase di compilazione mi dà i seguenti due errori:

C:\Programmi\Crimson Editor\template\esercizi\array>javac GestoreArray.java
GestoreArray.java:28: cannot find symbol
symbol : variable Input
location: class GestoreArray
A[i] = Input.readInt();
^
GestoreArray.java:48: cannot find symbol
symbol : variable Input
location: class GestoreArray
A[i] = Input.readInt();
^

Ora io non sono per niente esperto di Java...però credo di capire che è come se gli mancasse la classe Input per usare poter usare il metodo readInt() che viene usato per leggere un intero da tastiera ed assegnarlo ad A[i]....
ma è una classe di Java o è qualcosa che stà dando per buona lei? (mi viene il dubbio che sia una sua classe che non ha messo da nessuna parte nelle dispense...)

Allego tutto il listato della classe ma l'errore si presenta solo nei primi metodi come potete vedere

/** Classe contenitore di metodi utili per operare sugli array */

class GestoreArray{
	
	/** Visualizza sullo schermo gli elementi di un array
	    @param A di tipo array di tipo int: l'array da visualizzare */
	    
	public static void visualizzaArray(int[] A){
		
		int i;
		for(i=0; i<A.length; i++)
			System.out.print(A[i]+ " ");
		
		System.out.println();			// Per andare a capo
	}
		
	/** Legge uno alla volta gli elementi di un array
		@param A di tipo array di tipo int: l'array da inizializzare
		@return void: gli effetti dell'invocazione del metodo si manifestano sotto forma di effetti collaterali */
		
	public static void leggiArray(int[] A){
		
		/* Legge uno alla volta gli elementi dell'array A; utilizza pesantemente e positivamente gli effetti collaterali */
		int i;
		
		for(i=0; i<A.length; i++){
			System.out.print("elemento A["+i+"] = ");
			A[i] = Input.readInt();
		}
	}
		
	/** Crea un array, ne legge gli elementi uno alla volta e lo restituisce
		@param n di tipo int: la dimensione dell'array da creare
		@return il riferimento ad un array di tpo int */
	
	public static int[] creaELeggiArray(int n){
		
		/* Crea un array, ne legge gli elementi uno alla volta e lo restituisce */
		
		int [] A;			// Dichiaro l'array di interi A
		int i;
		
		A = new int[n];		// Crea l'arra A di n elementi
		
		/* Ciclo di lettura degli elementi dell'array */
		for(i=0; i<A.length; i++){
			System.out.print("elemento A["+i+"] = ");
			A[i] = Input.readInt();
		}
		
		return A;		// Restituisce il riferimento all'array A creato ed iniazializzato
	}
	
	/** Individua l'elemento di valore massimo in un array
		@param A di tipo array di tipo int
		@return l'elemento di valore massimo in A */
	
	public static int calcolaMax(int[] A){
		
		int max = A[0];
		int i;
		
		for(i=1; i<A.length; i++)
			if(A[i] > max) max = A[i];
		
		return max;				// Ritorna il valore massimo al chiamante
	}
	
	/** Individua l'elemento di valore minimo in un array
		@param A di tipo array di tipo int
		@return l'elemento di valore minimo in A */
	
	public static int calcolaMin(int[] A){
		
		int min = A[0];
		int i;
		
		for(i=1; i<A.length; i++)
			if(A[i] < min) min = A[i];
			
		return min;				// Ritorna il valore minimo al chiamante
	}
	
	/** Calcola la media aritmetica degli elementi di un array
		@param A di tipo array di int
		@return double, il valore della media aritmentica degli elementi di A */
		
	public static double calcolaMedia(int [] A){
		
		/* Calcola la media aritmetica degli elementi di A e la restituisce */
		
		double media = 0;
		int i;
		
		for(i=0; i<A.length; i++)
			media += A[i];
			
		return (double) media / A.length;
	}
	
	/** Verifica l'uguaglianza di due array
		@param A di tipo array di tipo int
		@param B di tipo array di tipo int
		@return boolean, se A e B hanno la stessa lunghezza e se gli elementi di A sono ordinatamente uguali agli elementi
		di B restituisce true, altrimenti restituisce false */
		
	public static boolean verificaSeUguali(int [] A, int [] B){
		
		boolean uguali;		// E' il valore da restituire
		int i = 0;
		
		/* Se le lunghezze dei due array sono diverse allora i due array non possono essere uguali */
		if(A.length != B.length) uguali = false;
		
		else{	// Se invece i due array hanno uguale lunghezza deve controllare elemento per elemento
			uguali = true;		// Inizializziamo la variabile a true e se l'ordine degli elementi non coincide la cambia
			
			while(i<A.length && uguali){	// Finchè deve ancora finire di scorrere l'array e finchè i 2 array sono uguali
				if(A[i] != B[i]) uguali = false;
				i++;
			}
		}
		
		return uguali;		// Restituisce al chiamante il valore booleano calcolato
	}
	
	/** Cerca un elemento in un array
		@param A di tipo array di tipo int
		@param B elemento di tipo int
		@return int: l'indice della prima occorrenza dell'elemento in A se l'elemento è contenuto in A, -1 altrimenti */
		
	public static int cercaElemento(int [] A, int elemento){
		
		int posizione = -1;		// Per contenere l'eventuale posizione di elemento
		int i = 0;
		boolean trovato = false;
		
		while(!trovato && i<A.length){
			if(A[i] == elemento){
				posizione = i;
				trovato = true;
			}
			
			i++;
		}
		
		return posizione;
	}
	
	/** Calcola il prodotto scalare di due array
		@param A di tipo array di tipo int
		@param B di tipo array di tipo int
		@return int, il prodotto scalare di A e B se hanno la stessa lunghezza, -1 altrimenti */
		
	public static int calcolaProdottoScalare(int [] A, int [] B){
		
		int risultato;
		int i;
		
		if(A.length != B.length){	// Se A e B hanno lunghezze diverse non può eseguire il prodotto scalare
			System.err.println("Errore: array di dimensioni differenti");	// e visualizza un messaggio di errore
			risultato = 1234756;	// Ed assegna a risultato un valore di errore
		}
		
		else{						// Altrimenti esegui il prodotto scalare tra i due array
			
			for(i=0; i<A.length; i++) 		// ??
				risultato += A[i]*B[i];
				
		}
		
		return risultato;
	}
	
	/** Sposta a destra di una posizione tutti gli elementi di un array tranne l'ultimo che viene spostato nella prima
	    posizione
	    @param A di tipo array di tipo int
	    @return void, gli effetti dell'invocazione del metodo si manifestano sotto forma di effetti collaterali */
	    
	public static void calcolaUnoShift(int [] A){
		
		int i;
		int primo = A[0];
		
		for(i=0; i<A.length-1; i++)
			A[i] = A[i+1];
		
		A[A.length-1] = primo;
	}
	
	/** Crea un array di tipo int [] e vi copia gli elementi di un array spostati a destra di una posizione tranne l'ultimo
	    che viene copiato in prima posizione.
	    @param A di tipo array di tipo int
	    @return int [], l'array contenente lo schift di A */
	    
	public static int [] creaECalcolaUnoShift(int [] A){
		
		int i;
		int [] B = new int[A.length];		// Definizione e creazione del nuovo array da restituire
		
		for(i=0; i<A.length-1; i++)
			B[i] = B[i+1];
			
		B[A.length-1] = A[1];
		
		return B;							// Ritorna il riferimento all'array creato
	}
	
	/** Sposta a destra di un numero variabile di posizioni tutti gli elementi di un array; gli ultimi elementi vengono
	    spostati nelle prime posizioni.
	    @param A di tipo array di tipo int
	   
	    @return void, gli effetti dell'invocazione del metodo si manifestano sotto forma di effetti collaterali 
	    
	public static void calcolaShiftGenerico(int [] A, int h){
		
		int i;
		int [] B = new int[h];				// Definizione e creazione dell'array di appoggio
		
		for(i=0; i<h; i++)					// Copia dei primi h elementi di A in B
			B[i] = A[i];
			
		for(i=0; i<A.length; i++)			// Shift degli elementi di A non copiati in B
			B[i] = A[(i+h) % A.length];
		
		for(i=0; i<h; i++)					// Copia degli elementi di B nelle ultime posizioni di A
			A[n-h+i] = B[i];		
	}
	*/
	
	/** Crea un array di tipo int [] e vi copia gli elementi di un array spostati a destra di un numero variabili di
	    posizioni (gli ultimi elementi vengono copiati nelle prime posizioni)
	    @param A di tipo array di tipo int
	    @param h di tipo int, il numero di posizioni di cui spostare gli elementi di A
	    @return int [], l'array contenente lo shift di A */
	    
	public static int[] creaECalcolaShiftGenerico(int [] A, int h){
		int i;
		int [] B = new int [A.length];			// Definizione e creazione dell'array da restituire
		
		for(i=0; i<A.length; i++)
			B[i] = A[(i+h) % A.length];		   // Ritorna il riferimento all'array creato
			
		return B;					
	}

}

Grazie
Andrea

[banryu79]

Il compilatore ti da quell'errore perchè la classe Input sicuramente è definita in un package che devi importare prima di usarla con l'istruzione import nomepackage; oppure la devi usare chiamandola con il nome esteso nomepackage.Input (previa inclusione del file .jar del package nel classpath).

@EDIT: comunque non è una classe del JDK della Sun, deve essere una classe che si è inventata lei.

[D4rkAng3l]

Originariamente inviato da banryu79

Il compilatore ti da quell'errore perchè la classe Input sicuramente è definita in un package che devi importare prima di usarla con l'istruzione import nomepackage; oppure la devi usare chiamandola con il nome esteso nomepackage.Input (previa inclusione del file .jar del package nel classpath).

quindi non è una classe propria del linguaggio Java nativamente?

Che palle...perchè non me lo hanno scritto da nessuna parte?