web-dev-qa-db-fra.com

Comment trouver la valeur maximale d'un ensemble de variables

Je me demandais si quelqu'un pouvait m'aider à trouver la valeur maximale d'un ensemble de variables et à les affecter à une autre variable. Voici un extrait de mon code qui peut aider à comprendre de quoi je parle.

// Ask for quarter values.
    System.out.println("What is the value of the first quarter?");
    firstQuarter = input.nextDouble();

    System.out.println("What is the value of the second quarter?");
    secondQuarter = input.nextDouble();

    System.out.println("What is the value of the third quarter?");
    thirdQuarter = input.nextDouble();

    System.out.println("What is the value of the fourth quarter?");
    fourthQuarter = input.nextDouble();

    //Tell client the maximum value/price of the stock during the year.     
    //maxStock = This is where I need help 
    System.out.println("The maximum price of a stock share in the year is: $" + maxStock + ".");
javavariablesmax
13
Cody B

En Java, vous pouvez utiliser Math.max comme ceci:

double maxStock = Math.max( firstQuarter, Math.max( secondQuarter, Math.max( thirdQuarter, fourthQuarter ) ) );

Pas le plus élégant, mais ça marchera.

Alternativement, pour une solution plus robuste, définissez la fonction suivante:

private double findMax(double... vals) {
   double max = Double.NEGATIVE_INFINITY;

   for (double d : vals) {
      if (d > max) max = d;
   }

   return max;
}

Vous pouvez ensuite appeler par:

double maxStock = findMax(firstQuarter, secondQuarter, thirdQuarter, fourthQuarter);
24
nybbler

Une méthode pour les gouverner tous

public static <T extends Comparable<T>> T max(T...values) {
    if (values.length <= 0)
        throw new IllegalArgumentException();

    T m = values[0];
    for (int i = 1; i < values.length; ++i) {
        if (values[i].compareTo(m) > 0)
            m = values[i];
    }

    return m;
}
4
mfc

Avec des variables primitives, le meilleur choix peut-être avec des tableaux ou des collections:

Tableaux:

double [ ] data = { firstQuarter , secondQuarter , thirdQuarter , fourtQuarter ) ;
Arrays . sort ( data ) [ 3 ] ;

Collections:

List<Double> data = new Arraylist<Double>();
data.add(firstQuarter);
data.add(secondQuarter);
data.add(thirdQuarter);
data.add(foutQuarter);
Collections.sort(data);
data.get(3);

Et si vous travaillez avec des objets, vous pouvez utiliser des collections avec un comparateur:

class Quarter {
    private double value;
    private int order;

    // gets and sets
}

Et pour obtenir la valeur maximale:

List<Quarter> list = new ArrayList<Quarter>();
Quarter fisrt = new Quarter();
first.setValue(firstQuarter);
first.setOrder(1);
list.add(first);
// Do the same with the other values
Collections.sort(list, new Comparator<Quarter>(){
    compare(Object o1, Object o2){
        return Double.valueOf(o1.getValue()).compareTo(o2.getValue());
    }
}

Cela peut être plus complexe, mais si vous travaillez avec des objets, je pense qu'il vaut mieux travailler.

2
Eldius
double [ ] data = { firstQuarter , secondQuarter , thirdQuarter , fourtQuarter ) ;
Arrays . sort ( data ) [ 3 ] ;
1
emory

Un peu tard pour la fête, mais pour tous ceux qui consultent cette question, Java 8 a des types de flux primitifs qui implémentent exactement cela

Collection<Integer> values = new ArrayList<>();
OptionalInt max = values.stream().mapToInt((x) -> x).max();

mapToInt est la fonction clé qui décrit comment convertir l'entrée en un type entier. Le flux résultant a alors des agrégateurs et des collecteurs supplémentaires spécifiques aux types entiers, l'un étant max().

La valeur du résultat peut ensuite être extraite de OptionalInt, si l'opération a réussi

1
brendon

Je crois maintenant en Java 8 la version la plus concise ressemblerait à ceci:

DoubleStream.of(firstQuarter , secondQuarter , thirdQuarter , fourtQuarter).max();
1
arjabbar
Max = firstQuarter;
If(secondQuarter > max)
   Max = secondQuarter;

... Etc

0
Rado