Comment réutiliser ce code au lieu de le copier et de le coller encore et encore

Question

J'ai un tableau d'objets et l'objet contient des membres de données tels que GoalsFor, GoalsAgainst et MatchPoints. Maintenant, j'ai la recherche et l'affichage des données en utilisant la méthode de recherche binaire pour une valeur donnée goalsFor ou goalsAgainst ou MatchPoints. Je fais une classe de recherche binaire pour faire l'opération de recherche, mais actuellement je dois faire trois des classes de recherche binaire pour chaque membre de l'objet pour les trois opérations. Est-ce que je peux réutiliser le code de recherche binaire au lieu de le copier trois fois.

Ceci est un problème de devoirs mais je suis en train d'assommer mon doute est plus général. Contrainte: recherche linéaire non autorisée et pas construit en fonction, sauf i/o peut être utilisé

public class BinarySearchPoints 
{ 
    public static void search(Teams arr[], int searchValue, int start , int end) 

    { 
    if(start > end) 
     return; 
    int mid = (end + start)/2; 
    if(searchValue == arr[mid].points) 
    { 
     System.out.print(arr[mid].toString()); 
     search(arr, searchValue, mid + 1, end); 
     search(arr, searchValue, start, mid - 1); 
    } 
    else if(searchValue < arr[mid].points) 
     { 
      search(arr, searchValue, mid + 1, end); 
     } 
    else 
     search(arr, searchValue, start, mid - 1); 

    } 
} 

la seule chose que je suis en train de changer dans d'autres implémentations de recherche binaire utilise goalsFor et Buts contre au lieu de points

Answer 1

Vous pouvez définitivement généraliser votre méthode de recherche binaire.

La première chose à faire est de considérer ce dont votre recherche binaire a besoin à partir de la collection de données qui lui a été transmise. Il s'avère que la seule chose dont il a besoin est une capacité à comparer un élément de données à une valeur de recherche.

La prochaine chose est de trouver un moyen d'exprimer la comparaison d'une manière abstraite, par ex. comme une interface. Votre interface aurait une seule méthode qui répond à la question "Où est l'élément X par rapport au nombre donné"?

Vous pouvez l'exprimer en Java comme interface générique:

interface ElementComparator<E> { 
    // This assumes that you always search for an int property 
    int compare(E element, int value); 
} 

Votre méthode de comparaison doit retourner valeur négative si l'attribut de E est inférieure à V, une valeur positive si elle est supérieure à V, et zéro si les deux sont égaux. V doit mettre en œuvre l'interface Comparable.

Maintenant, votre méthode binarySearch pourrait être définie comme suit:

T binarySearch<E>(
    Collection<E> data 
, int value 
, ElementComparator<E> comparator 
) { 
    ... 
} 

Pour décider d'aller à droite ou à gauche du milieu, vous devez appeler comparator.compare(data.get(mid), value); et vérifier le résultat.

Maintenant, vous pouvez appeler votre binarySearch comme ceci:

List<Teams> list = ... 
Teams fivePoints = binarySearch(list, 5, new ElementComparator<Teams>() { 
    public int compare(Teams element, int value) { 
     return Integer.compare(element.points, value); 
    } 
}); 
Teams fiveAgainst = binarySearch(list, 5, new ElementComparator<Teams>() { 
    public int compare(Teams element, int value) { 
     return Integer.compare(element.against, value); 
    } 
}); 

Notez comment la fonction de rappel de comparaison est fourni en ligne avec l'appel: c'est là que la magie se produit - quand binarySearch mise en œuvre veut comparer un Team avec value, il appelle compare, qui à son tour appelle Integer.compare sur element.points ou element.against, en fonction du rappel.