Bereken het gemiddelde in Java

EDIT: ik heb code geschreven voor het gemiddelde, maar ik weet niet hoe ik het zo moet maken dat het ook ints gebruikt van mijn args.lengthin plaats van de array.

Ik moet een Java-programma schrijven dat het volgende kan berekenen:

1. het aantal ingelezen gehele getallen
2. de gemiddelde waarde die geen geheel getal hoeft te zijn!

OPMERKING: ik wil niet het gemiddelde uit de array berekenen, maar de gehele getallen in de args.

Momenteel heb ik dit geschreven:

int count = 0;
for (int i = 0; i<args.length -1; ++i)
    count++;
    System.out.println(count);
}
int nums[] = new int[] { 23, 1, 5, 78, 22, 4};
double result = 0; //average will have decimal point
for(int i=0; i < nums.length; i++){
    result += nums[i];
}
System.out.println(result/count)

Kan iemand mij in de goede richting leiden? Of geef een voorbeeld dat me op de juiste manier begeleidt om deze code vorm te geven?

Bij voorbaat dank.

Antwoord 1, autoriteit 100%

Een kleine wijziging aan uw code is voldoende (met wat var-naamgeving voor de duidelijkheid):

double sum = 0; //average will have decimal point
for(int i=0; i < args.length; i++){
   //parse string to double, note that this might fail if you encounter a non-numeric string
   //Note that we could also do Integer.valueOf( args[i] ) but this is more flexible
   sum += Double.valueOf( args[i] ); 
}
double average = sum/args.length;
System.out.println(average );

Merk op dat de lus ook kan worden vereenvoudigd:

for(String arg : args){
   sum += Double.valueOf( arg );
}

Bewerken: de OP lijkt de array argste willen gebruiken. Dit lijkt een String-array te zijn, dus het antwoord dienovereenkomstig bijgewerkt.

Bijwerken:

Zoxqoj correct heeft opgemerkt, wordt in de bovenstaande code niet voor integer/dubbele overflow gezorgd. Hoewel ik aanneem dat de invoerwaarden klein genoeg zijn om dat probleem niet te hebben, is hier een fragment om te gebruiken voor echt grote invoerwaarden:

BigDecimal sum = BigDecimal.ZERO;
for(String arg : args){
  sum = sum.add( new BigDecimal( arg ) );
}

Deze aanpak heeft verschillende voordelen (ondanks dat hij wat langzamer is, dus gebruik hem niet voor tijdkritische operaties):

• Precisie blijft behouden, met dubbel verlies je geleidelijk aan precisie met het aantal wiskundige bewerkingen (of krijg je helemaal geen exacte precisie, afhankelijk van de cijfers)
• De kans op overlopen is praktisch geëlimineerd. Houd er echter rekening mee dat een BigDecimalgroter kan zijn dan wat in een doubleof longpast.

Antwoord 2, autoriteit 43%

int values[] = { 23, 1, 5, 78, 22, 4};
int sum = 0;
for (int i = 0; i < values.length; i++)
    sum += values[i];
double average = ((double) sum) / values.length;

Antwoord 3, autoriteit 29%

Dit

for (int i = 0; i<args.length -1; ++i)
    count++;

berekent in feite args.lengthopnieuw, alleen onjuist (lusvoorwaarde moet i<args.lengthzijn). Waarom niet gewoon rechtstreeks args.length(of nums.length) gebruiken?

Anders lijkt je code in orde. Hoewel het lijkt alsof u de invoer van de opdrachtregel wilt lezen, maar niet weet hoe u dat in een reeks getallen moet omzetten, is dit uw echte probleem?

Antwoord 4, autoriteit 14%

Het lijkt een oude thread, maar Java is sindsdien geëvolueerd & introduceerde Streams & Lambdas in Java 8. Dus kan iedereen helpen die het wil doen met Java 8-functies.

• In jouw geval wil je args die String[] is, converteren naar double
  of int. U kunt dit doen met Arrays.stream(<arr>). Zodra u een stroom String-array-elementen hebt, kunt u mapToDouble(s -> Double.parseDouble(s))gebruiken die de stroom van Strings omzet in een stroom van doubles.
• Vervolgens kunt u Stream.collect(supplier, accumulator, combiner)gebruiken om het gemiddelde te berekenen als u de incrementele berekening zelf wilt regelen. Hier is een goed voorbeeld.
• Als u niet stapsgewijs gemiddelden wilt doen, kunt u direct Java’s Collectors.averagingDouble()gebruiken, die het gemiddelde direct berekent en retourneert. sommige voorbeelden hier.

Antwoord 5

System.out.println(result/count) 

u kunt dit niet doen omdat result/count geen String-type is en System.out.println() alleen een String-parameter nodig heeft. probeer misschien:

double avg = (double)result / (double)args.length

Antwoord 6

voor 1. het aantal gehele getallen dat wordt ingelezen, kunt u de eigenschap length van een array gebruiken, zoals :

int count = args.length

wat je geen elementen in een array geeft.
En 2. om de gemiddelde waarde te berekenen:
je doet het op de juiste manier.

Antwoord 7

In plaats van:

int count = 0;
for (int i = 0; i<args.length -1; ++i)
    count++;
System.out.println(count);
 }

je kunt gewoon

int count = args.length;

Het gemiddelde is de som van je argumenten gedeeld door het aantal argumenten.

int res = 0;
int count = args.lenght;
for (int a : args)
{
res += a;
}
res /= count;

je kunt deze code ook korter maken, ik zal je vragen of je hulp nodig hebt!

Dit zijn mijn eerste antwoorden, dus vertel het me als er iets mis is!

Antwoord 8

Als je de gehele getallen uit de opdrachtregelargs probeert te halen, heb je zoiets als dit nodig:

public static void main(String[] args) {
    int[] nums = new int[args.length];
    for(int i = 0; i < args.length; i++) {
        try {
            nums[i] = Integer.parseInt(args[i]);
        }
        catch(NumberFormatException nfe) {
            System.err.println("Invalid argument");
        }
    }
    // averaging code here
}

Wat betreft de eigenlijke middelingscode, anderen hebben gesuggereerd hoe je dat kunt aanpassen (dus ik zal niet herhalen wat ze hebben gezegd).

Bewerken: eigenlijk is het waarschijnlijk beter om het gewoon in de bovenstaande lus te plaatsen en de numsarray helemaal niet te gebruiken

Antwoord 9

Ik ga je twee manieren laten zien. Als u niet veel statistieken in uw project nodig heeft, implementeert u gewoon het volgende.

public double average(ArrayList<Double> x) {
    double sum = 0;
    for (double aX : x) sum += aX;
    return (sum / x.size());
}

Als je van plan bent veel statistieken te maken, kun je net zo goed het wiel niet opnieuw uitvinden. Dus waarom niet eens kijken op http://commons.apache.org/proper/ commons-math/userguide/stat.html

Je zult verliefd worden!

Antwoord 10

public class MainTwo{
    public static void main(String[] arguments) {
        double[] Average = new double[5];
        Average[0] = 4;
        Average[1] = 5;
        Average[2] = 2;
        Average[3] = 4;
        Average[4] = 5;
        double sum = 0;
        if (Average.length > 0) {
            for (int x = 0; x < Average.length; x++) {
                sum+=Average[x];
                System.out.println(Average[x]);
            }
            System.out.println("Sum is " + sum);
            System.out.println("Average is " + sum/Average.length);
      }
   }
}