Jak znaleźć maksymalną wartość zestawu zmiennych?

Question

Zastanawiałem się, czy ktoś mógłby mi pomóc znaleźć maksymalną wartość zestawu zmiennych i przypisać je do innej zmiennej. Oto fragment kodu, który może pomóc w zrozumieniu tego, o czym mówię.

// 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 + "."); 

Answer 1

w Javie, można użyć Math.max takiego:

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

Nie najbardziej eleganckie, ale to będzie działać.

Alternatywnie, bardziej niezawodne rozwiązanie zdefiniować następującą funkcję:

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

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

    return max; 
} 

które można następnie połączenia przez:

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

Answer 2

Max = firstQuarter; 
If(secondQuarter > max) 
    Max = secondQuarter; 

... I tak dalej

Answer 3

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

Answer 4

ze zmiennymi prymitywnych najlepszym wyborem może z tablic lub Kolekcje:

Tablice:

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

Kolekcje:

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

A jeśli pracujesz z obiektami można użyć Collections z komparatora:

class Quarter { 
    private double value; 
    private int order; 

    // gets and sets 
} 

i uzyskać wartość maksymalna:

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()); 
    } 
} 

To może być bardziej złożone, ale jeśli pracujesz z obiektami, myślę, że lepiej jest pracować.

Answer 5

import java.util.Scanner; 


public class dmar { 

public static void main (String [] srgs){ 

    Scanner dmar=new Scanner(System.in);{ 

     { 

System.out.println ("inter number of x plz") ; 

double x=dmar.nextDouble(); 

System.out.println ("inter number of y plz") ;{ 


double y=dmar.nextDouble(); 

System.out.println ("inter number of t plz") ; 
double t=dmar.nextDouble(); 

System.out.println ("inter number of f plz") ; 
double f=dmar.nextDouble(); 

{ 

{ 
if (x>y); 

System.out.println("x biger than y"); 


if (x>t); 
System.out.println("x biger than t"); 

if (x>f); 

System.out.println("x biger than f"); 


if (y>x); 
System.out.println("y biger than x"); 



if (y>t); 
System.out.println("y biger than t"); 

if (y>f); 
System.out.println("y biger than f"); 

if (t>x&t>f&t>y); 
System.out.println("t biger than x"); 

if (t>y); 
System.out.println("t biger than y"); 

if (t>f); 
System.out.println("t biger than f"); 

if (f>x); 
System.out.println("f biger than x"); 


if (f>y); 
System.out.println("f biger than y"); 


     if (f>t); 
System.out.println("f biger than t"); 

} 

Answer 6

Jednym ze sposobów, aby wykluczyć je wszystkie

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; 
} 

Answer 7

Trochę późno do partii, ale dla nikogo oglądania to pytanie, Java 8 ma prymitywne typy strumieniowych, które implementują dokładnie ten

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

mapToInt to kluczowa funkcja opisująca sposób konwersji wejścia na typ całkowity. Wynikowy strumień ma następnie dodatkowe agregatory i kolektory specyficzne dla typów całkowitych, przy czym jednym z nich jest max().

Wartość wynik może być następnie ekstrahowany z OptionalInt, jeśli operacja powiodła

Answer 8

wierzę teraz w Java 8 wersja najbardziej zwięzły będzie wyglądać następująco:

DoubleStream.of(firstQuarter , secondQuarter , thirdQuarter , fourtQuarter).max();