Salve a tutti,
se ho un HashSet di FrequentPattern e faccio miohashset.remove(fp) per far si che funzioni cosa devo reimplementare?

Ovvero ho reimplementato sia equals che comperaTo eppure mettendo dei punti di debug dentro entrambi non sembra andarci mai (e difatti sembra continuare a fare i confronti sull'indirizzo di memoria).

Qualche suggerimento? cosa può essermi sfuggito?


Questa è la classe FrequentPattern in cui ho reimplementato i due metodi:

codice:
package mining;
import java.util.*;

import mappa.Cella;
import mappa.Mappa_reale;

/** @author Rana Rocco, Colangiuli Guido
 * 

 La classe FrequentPattern rappresenta un itemset (o pattern) frequente[/b]</p>*/


public class FrequentPattern implements Comparable<FrequentPattern>{

	/**
	*@attribute private List<Item> fp
	*

array che contiene riferimenti a oggetti istanza della
	*classe Item che definiscono il pattern</p>*/
	private List<Item> fp;/*= new LinkedList<Item>();*///Item fp[];
	
	/**@attribute private float support
	 *

valore di supporto calcolato per il pattern fp</p>*/
	private float support;
	
	/**
	*

Comportamento: costruttore che alloca fp come array di dimensione 0</p>
	*/
	public FrequentPattern(){
		fp= new LinkedList<Item>();		
	}
	
	/**
	*

Comportamento: si estende la dimensione di fp di 1 e si inserisce il
	*ultima posizione líargomento della procedura</p>
	*@param item (oggetto Item da aggiungere al pattern)
	*/
	void addItem(Item item)
	{
		fp.add(item);
	}
	
	/**
	*

Comportamento: restituisce l'item in posizione index di fp</p>
	*@param index (posizione in fp)
	*@return Item
    */
	Item getItem(int index)
	{
		return fp.get(index);
	}
	
	/**
	*

Comportamento: verifica se l'Item in input Ë contenuto nel frequent pattern</p>
	*@param index (posizione in fp)
	*@return Item
    */
	boolean containsItem(Item it)
	{
		for(int i = 0; i < fp.size(); i++)
			if(fp.get(i).compareTo(it) == 0)
				return true;
		return false;
	}
	
	/**

Comportamento: restituisce il membro support</p>
	*@return float*/
	float getSupport()
	{
		return support;
	}
	
	/**
	*

Comportamento: restituisce la dimensione (lunghezza) di fp</p>
	*@return int
	*/
	int getPatternLength()
	{
		return fp.size();
	}
	
	/**
	*

Comportamento: assegna al membro support il parametro della procedura </p>
	*@param support (valore di supporto del pattern)
	*/
	void setSupport(float support)
	{
		this.support = support;
	}
	
	/**
	*

Comportamento: si scandisce fp al fine di concatenare in una stringa
	*la rappresentazione degli item; alla fine si concatena il supporto</p>
	*@return String
	*/
	
	public String toString(){
		String value="";
		
		Iterator<Item> e = fp.listIterator();
		while(e.hasNext())
		    value+=e.next();
		if(fp.size()>0){
			value+= "   Supporto : "+"["+support+"]";
		}
		return value;
	}

	/**
	*

Comportamento: Il metodo confronta due frequent pattern</p>
	*@return String
	*/
	public int compareTo(FrequentPattern o) {
		if(o.getPatternLength()!=this.getPatternLength())
			return -1;
		for(int i = 0; i < this.fp.size(); i++)
		{
			/*if(o.getItem(i).getcella().confrontocentroidi(fp.get(i).getcella())!=0)
			{
				return -1;
			}*/
			int confronto = o.getItem(i).compareTo(fp.get(i));
			if(confronto != 0)
			{
				return confronto;
			}
		}
		return 0;
	}
	
	/**
	*

Comportamento: Il metodo confronta due frequent pattern</p>
	*@return String
	*/
	public boolean equals(Object obj) {
		System.out.println("EQUALSSSS!!");
		if(((FrequentPattern)obj).getPatternLength()!=this.getPatternLength())
			return false;
		for(int i = 0; i < this.fp.size(); i++)
		{
			/*if(o.getItem(i).getcella().confrontocentroidi(fp.get(i).getcella())!=0)
			{
				return -1;
			}*/
			int confronto = ((FrequentPattern)obj).getItem(i).compareTo(fp.get(i));
			if(confronto != 0)
			{
				return false;
			}
		}
		return true;
	}
	




}