Définir une méthode par récurrence

Je souhaite définir une méthode "min" qui, n'importe le nombre d'argument, me renvoie le plus petit élément. Mais n'ayant pas très envie d'écrire une méthode pour chaque nombre d'élément, je voulais savoir s'il y a un moyen de définir une méthode par récurrence. En gros, lorsque j'écrit min(a, b, c), elle va considérer ça comme min(a, min(b, c)) etc.

salut
tu peux définir ta méthode avec un nombre variable d'argument;

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
public int min( int ... t) // ton argument est un tableau 
{
    int size =t.length ;
    if (size==0)
       return 0; //pas d’élément on peut lever une exception.
   if( size==1)
       return t[0];
  int x= t[0];
  for( int i=1;i<size;i++)
  {
  if( t[i]<x) x=t[i];
  }
return x;
}

et pour l'appel

Code:

1
2
 
min( 1, 2, 3);

Je ne comprends pas l'écriture min(int ... t). Que signifient les trois points?

c'est pour définir un nombre variable d'argument.

c'est équivalent a int t[]

tableau d'équivalence entre int t[] et int ... t
Entete de la Méthode
Code:

1 2 int min( int t[])
Code:

1 2 int min( int ... t)
[
Appel de la methode
Code:

1 2 3 min(new int[]{1,2}); min(new int[]{1,2,3}); // min(1,2) interdit
Code:

1 2 3 min(1,2); min(1,2,3); min(new int[]{1,2,3}); // possible

Merci énormément!

Salut,

Citation:

Envoyé par miaous

tu peux définir ta méthode avec un nombre variable d'argument;

+1 très bonne solution.

J'aurais toutefois deux remarques à faire :

On peut appeler la méthode avec zéro ou un seul paramètre, ce qui n'est pas très logique.
Cela crée un tableau temporaire à chaque appel (même vide), ce qui est inutile et "couteux" lorsqu'on veut simplement comparer 2 valeurs.

En fait on peut pallier à cela assez facilement...

Pour le premier point il suffit d'ajouter deux paramètres classiques, pour avoir obligatoirement au minimum 2 valeurs à comparer :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 public static int min(int a, int b, int...othersValues) { int min = Math.min(a, b); for (int value : othersValues) { if (value<min) { min = value; } } return min; } // min() et min(1) provoqueront des erreurs de compilation // min(1,2) sera équivalent à min(1,2,new int[]{}) // min(1,2,3) sera équivalent à min(1,2,new int[]{3}) // etc.
Pour le second point, il suffit de surcharger la méthode avec une version ne comportant que 2 paramètres :
Code:

1 2 3 public static int min(int a, int b) { return Math.min(a, b); }
Lorsqu'on a exactement 2 paramètres c'est cette dernière qui sera appelée (sans créer de tableau vide), sinon ce sera la version avec argument variable...

A noter que l'on peut faire la même la même chose avec des objets, toutefois il faut un peu toucher aux Generics.

On a deux solutions. Pour les classes qui implémentent Comparable :
Il faut juste toucher un peux aux Generics :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 public static <T extends Comparable<T>> T min(T a, T b) { if (a.compareTo(b) <= 0) { return a; } return b; } @SafeVarargs // indique que l'on ne modifie pas le tableau de l'ellipse public static <T extends Comparable<T>> T min(T a, T b, T...othersValues) { T min = min(a,b); for (T value : othersValues) { if (value.compareTo(min) < 0) { min = value; } } return min; }
Sinon il faut impérativement utiliser un Comparator pour effectuer la comparaison :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 public static <T> T min(Comparator<T> comparator, T a, T b) { if (comparator.compare(a,b) <= 0) { return a; } return b; } @SafeVarargs // indique que l'on ne modifie pas le tableau de l'ellipse public static <T> T min(Comparator<T> comparator, T a, T b, T...othersValues) { T min = min(comparator,a,b); for (T value : othersValues) { if (comparator.compare(value,min) < 0) { min = value; } } return min; }
a++