[JAVA] Problema metodo con Array

[Mrmorrison]

Salve Ragazzi, allora io ho una classe Set che contiene tre metodi per una semplice gestione di un array. Allora un metodo controlla se il membro che cerco di passargli è già presente nell'array e fino qui credo di esserci.

Il problema viene quando devo andare ad aggiungere un elemento nell'array.
Con questo codice chiamo il metodo addMember(int n) ed ok mi inserisce il valore nella prima posizione. Poi quando lo vado a richiamare mi inserisce il valore si ma lo sostituisce a quello che ha inserito prima sempre in prima posizione. Quindi non riesco ad aggiornare il valore di pos..come posso fare?!

public class Set { 
private int numbers[]; 
private int pos;
 
public Set(){ 
pos = 0; 
} 

public boolean isMember(int a){ 
for (int i = 0;i<numbers.length;i++){ 
if(numbers[i] == a ){
 return true; 
} 

}
 return false; 
} 

public void addMember (int n){
 if (isMember(n) == false ){
 numbers[pos++] = n; 
} 
} 

public void showSet(){ 
for(int i = 0; i< numbers.length; i++){ 
System.out.println(numbers[i]); 
} 
} 

public int[] getNumbers() { 
return numbers; 
} 

public void setNumbers(int numbers[]) { 
this.numbers = numbers; 
} 
}

[Alex'87]

Beh, pos è inizializzato a 0.

		Set set = new Set();
		set.setNumbers(new int[] { 1, 2, 3, 4 });
		set.addMember(5);
		set.showSet();

Cosa succede in questo esempio? numbers ha già 4 elementi e pos parte sempre da zero quando dovrebbe partire da numbers.length. Ma ora c'è un altro problema: la dimensione dell'array: è già pieno, se cerchi di aggiungere elementi darà IndexOutOfBoundsException!

Io rivedrei tutta la classe, in particolare impedendo di passare dall'esterno l'array di lavoro e gestendo la riallocazione.

ps: è inutile usare il tag code se il codice non è indentato in partenza...

[Mrmorrison]

Scusami forse non ho specificato l'array è definito è di 100 elementi.
Ora modificando ogni dato che provo ad inserire va in eccezione come dicevi te appunto perchè pos prende la dimensione dell' array. Allo stesso modo però non ho idea di come risolvere. aiutino?!

[schumy2000]

la butto lì....perché non prendi in considerazione l'idea di usare un Vector o una LinkedList di java.util?

Altrimenti con l'array ogni volta che tenti di aggiungere un nuovo elemento dei creare un nuovo array con una posizione in più, quindi copiare il vecchio array nel nuovo e aggiungere l'elemento che gli passi.

Ciao.

[Alex'87]

Originariamente inviato da schumy2000
Altrimenti con l'array ogni volta che tenti di aggiungere un nuovo elemento dei creare un nuovo array con una posizione in più, quindi copiare il vecchio array nel nuovo e aggiungere l'elemento che gli passi.

Una posizione in più? Non scherziamo dai... La riallocazione è costosa, la dimensione va aumentata in modo più furbo, come ad esempio viene fatto in ArrayList/Vector (ArrayList dovrebbe essere un +50%, Vector raddoppia in genere.)

[schumy2000]

Totalmente d'accordo, ma dal momento che sono cento elementi non credo il sistema crashi.
I problemi sorgono quando gli elementi cominciano a crescere, per questo gli ho suggerito di usare strutture dati già pronte come Vector & company

[Alex'87]

Originariamente inviato da Mrmorrison
Scusami forse non ho specificato l'array è definito è di 100 elementi.

Non importa quanto grande è, l'array che gli passi sarà sempre già pieno.

[Mrmorrison]

Allora Alex ti riformulo la domanda in un altra maniera....

Come avresti risolto tu questo problemino?!

Grazie del consiglio schumi...avrei risolto anche io così...però il problema è che l'esercizio và fatto in questa maniera.

[Alex'87]

Originariamente inviato da Mrmorrison
Allora Alex ti riformulo la domanda in un altra maniera....

Come avresti risolto tu questo problemino?!

Una cosa del genere:

public class Set
{

    private int[] numbers;
    private int firstFreeIndex;

    public Set()
    {
	numbers = new int[10]; // TODO parametrizzare questo valore
    }

    public boolean isMember(int element)
    {
	/*
	 * non serve scorrere tutto l'array ma solo fino a dove e' stato
	 * riempito: gli elementi in posizione >= firstFreeIndex saranno 0,
	 * valore di default degli interi (o null in caso di oggetti)
	 */
	for (int i = 0; i < firstFreeIndex; i++)
	{
	    if (numbers[i] == element)
	    {
		return true;
	    }
	}

	return false;
    }

    public void addMember(int element)
    {
	if (firstFreeIndex == numbers.length)
	{
	    // rialloca l'array
	    int[] old = new int[numbers.length];
	    System.arraycopy(numbers, 0, old, 0, numbers.length);
	    numbers = new int[numbers.length + 100]; // TODO parametrizzare
	    System.arraycopy(old, 0, numbers, 0, old.length);
	}

	if (!isMember(element))
	{
	    numbers[firstFreeIndex++] = element;
	}
    }

    public int get(int index)
    {
	// TODO gestire caso index < 0
	// TODO gestire caso index > numbers.length
	// TODO gestire caso index >= firstFreeIndex
	return numbers[index];
    }

    public void print()
    {
	// TODO ottimizzare usando StringBuilder
	String s = "[";
	for (int i = 0; i < firstFreeIndex; i++)
	{
	    s += numbers[i];
	    if (i != firstFreeIndex - 1)
	    {
		s += ", ";
	    }
	}
	s += "]";

	System.out.println(s);
    }

}

public class Main
{
     
    public static void main(String[] args)
    {
	Set set = new Set();

	set.addMember(10);
	set.addMember(3);
	set.addMember(4);
	set.addMember(1);
	set.addMember(3);
	set.addMember(15);
	set.addMember(4);
	set.addMember(100);

	set.print();
    }

}