Arithmétique générique en Java

Question

J'ai une classe de filtre dans laquelle l'utilisateur doit déclarer le type (par exemple Filter<Double>, Filter<Float> etc.). La classe implémente ensuite un filtre de moyenne mobile afin que les objets de la classe soient ajoutés. Ma question est comment faire cela? Je suis désolé si la réponse est simple mais je me suis embrouillé en y pensant trop: je pense: p.

public abstract class FilterData<T> 
{ 
private final List<T> mFilter; 
private T mFilteredValue; // current filtered value 
protected Integer mSize = 10; 
private T mUnfilteredValue; // current unfiltered value 

public FilterData() 
{ 
    mFilter = new ArrayList<T>(); 
} 

public FilterData(int size) 
{ 
    mSize = size; 
    mFilter = new ArrayList<T>(mSize); 
} 

public abstract T add(final T pFirstValue, final T pSecondValue); 

@SuppressWarnings("unchecked") 
public T filter(T currentVal) 
{ 
    T filteredVal; 
    mUnfilteredValue = currentVal; 
    push(currentVal); 

    T totalVal = (T) (new Integer(0)); 
    int numNonZeros = 1; 
    for (int i = 0; i < mFilter.size(); ++i) 
    { 
     if (mFilter.get(i) != (T) (new Integer(0))) 
     { 
      ++numNonZeros; 
      T totalValDouble = add(mFilter.get(i), totalVal); 
      totalVal = totalValDouble; 
     } 
    } 
    Double filteredValDouble = (Double) totalVal/new Double(numNonZeros); 
    filteredVal = (T) filteredValDouble; 
    mFilteredValue = filteredVal; 
    return filteredVal; 
} 

public T getFilteredValue() 
{ 
    return mFilteredValue; 
} 

public List<T> getFilterStream() 
{ 
    return mFilter; 
} 

public T getUnfilteredValue() 
{ 
    return mUnfilteredValue; 
} 

public void push(T currentVal) 
{ 
    mFilter.add(0, currentVal); 
    if (mFilter.size() > mSize) 
     mFilter.remove(mFilter.size() - 1); 
} 

public void resizeFilter(int newSize) 
{ 
    if (mSize > newSize) 
    { 
     int numItemsToRemove = mSize - newSize; 
     for (int i = 0; i < numItemsToRemove; ++i) 
     { 
      mFilter.remove(mFilter.size() - 1); 
     } 
    } 
} 
} 

Ai-je raison d'inclure la méthode abstraite Ajouter et si oui, comment dois-je étendre la couverture correctement classe à des types primitifs (par exemple float, double, entier, etc.) Merci Chris

EDIT :

Toutes mes excuses pour ne pas être clair. Ce n'est pas un devoir, j'ai peur, ces jours sont loin derrière moi. Je suis tout à fait nouveau à Java étant venu d'un arrière-plan C++ (d'où l'attente d'une surcharge de l'opérateur facile). Quant à la méthode "push". Je m'excuse pour la méthode add, c'est simplement ajouter une valeur à une liste, pas l'addition de la variable à laquelle je faisais référence (j'ai fait une note pour changer le nom de ma méthode alors!). La classe est utilisée pour fournir une interface pour construire une liste d'une longueur spécifiée, la peupler de variables et obtenir une moyenne sur les derniers «x» cadres pour aplanir les pics dans les données. Lorsqu'un nouvel élément est ajouté à l'objet FilterData, il est ajouté au début de la liste et le dernier objet est supprimé (à condition que la liste ait atteint la taille maximale autorisée). Donc, pour fournir une moyenne mobile continue, je dois additionner et diviser les valeurs dans la liste. Cependant, pour effectuer cette addition, je vais devoir trouver un moyen d'ajouter les objets ensemble. (C'est simplement une classe d'aide donc je veux le rendre aussi générique que possible). Est-ce que cela le rend plus clair? (Je suis conscient que le code est très Mickey Mouse mais je voulais le rendre aussi clair et simple que possible).

Answer 1

Ce que vous essayez de faire est de créer un objet Queue d'objets de taille fixe, sur lequel vous voulez calculer une moyenne. Avec la situation triviale que vous avez size = 2 et stocker deux entiers 1 & 2 vous avez une moyenne de 1.5 il est donc raisonnable de définir le type de retour de votre méthode de filtre pour doubler.

Vous pouvez écrire ce code similaire à ce

public abstract class FilterData<T extends Number> { 
    private final Queue<T> mFilter = new LinkedList<T>(); 
    protected Integer mSize; 

    public FilterData() { 
     this(10); 
    } 

    public FilterData(int size) { 
     mSize = size; 
    } 

    public double filter(T currentVal) { 
     push(currentVal); 

     double totalVal = 0d; 
     int numNonZeros = 0; 
     for (T value : mFilter) { 
      if (value.doubleValue() != 0) { 
       ++numNonZeros; 
       totalVal += value.doubleValue(); 
      } 
     } 

     return totalVal/numNonZeros; 
    } 

    public void push(T currentVal) { 
     mFilter.add(currentVal); 
     if (mFilter.size() > mSize) 
      mFilter.remove(); 
    } 

    public void resizeFilter(int newSize) { 
     if (mSize > newSize) { 
      int numItemsToRemove = mSize - newSize; 
      for (int i = 0; i < numItemsToRemove; ++i) { 
       mFilter.remove(); 
      } 
     } 
     mSize = newSize; 
    } 
} 

Vous devez noter que c'est pas thread-safe.