Beregning af gennemsnit?

noget a la

double snit(ArrayList k)
{
  double sum = 0;
  for (int i=0 ; i<k.size() ; i++)
    sum += k.get(i);
  return sum/k.size();
}

et eksempel med array af int..

public class testing
{
    public static void main(String[] arguments)
    {
        int[] arrayMedTal = {10,20,30,50};

        int index = 0;
        int sum = 0;
        int gns = 0;
       
        for(index = 0; index<arrayMedTal.length; index++)
        {
            sum = sum + arrayMedTal[index];
        }
        gns = sum / (index+1);
        System.out.println(\"Summen af tal i array: \" + sum);
        System.out.println(\"Antal tal i array: \" + index);
        System.out.println(\"Gennemsnit: \" + gns);
    }
}

Der er lidt besværligt at bruge ArrayList til det formål.
Da en ArrayList kun kan indeholde objekter, skal  du wrappe og unwrappe dine karakterer.
Ved du ikke på forhånd, hvor mange karakterer du skal bruge, så du kan bruge et Array istedet?

mosquito => du har da fået rimelig gode karakterer (20,30,50) ;-P

Nej jeg ved ikke antallet af karaktere på forhånd. Da der skulle kunne tilføjes og fjerns karakter løbende..

Forudsat at din liste indeholder wrapped integers

    public double gennemsnit(ArrayList list) {
        double sum = 0;
        for ( int i = 0 ; i < list.size() ; i++ ) {
            sum += ((Integer)(list.get(i))).intValue();
        }
        return( sum/list.size() );
    }

greybeard => Er det ikke muligt at bruge metoden toArray på en list?

Jo, men for at gemme karakterene i en ArrayList skal de wrappes. Det vil de stadig være, hvis man efterfølgende bruger toArray(), og så er der ikke meget vundet.

greybeard => men hvordan wrapper man så objekterne? Er det komplekst at gøre?

import java.util.*;

public class Gennemsnit {
    static ArrayList list =  new ArrayList();
   
    public static void main( String[] argv ){
        list.add(new Integer(7));
        list.add(new Integer(9));
        list.add(new Integer(8));
        list.add(new Integer(11));
        list.add(new Integer(5));
        list.add(new Integer(10));
        list.add(new Integer(7));
        list.add(new Integer(6));
        System.out.println( new Gennemsnit().gennemsnit(list) );
    }
   
    public double gennemsnit(ArrayList list) {
        double sum = 0;
        for ( int i = 0 ; i < list.size() ; i++ ) {
            sum += ((Integer)(list.get(i))).intValue();
        }
        return( sum/list.size() );
    }
}

greybeard:

Du kan da bare regne på Double som er et objekt så er det ikke noget problem.




Forresten er det en god ting at bruge en Iterator til at gå igennem en Collection istedet for en for løkke. Man kan ligeså godt bruge den funktionalitet der er lavet til formålet.

disky >> Hvad angår Iteratoren er jeg da enig, men jeg finder ikke væsentligt, sålænge det ikke er en flertrådet app.

Den med at regne på Double som objekt må du forklare nærmere. Så vidt jeg kan se er der ikke metoder til arimetik i wrapperklasserne??

greybeard:

Du har selvfølgelig helt ret med Double, jeg er ikke vågen endnu.

Men hvorfor man kun skal bruge iterator i en flertrådet app. må du gerne lige forklare.

Så vidt jeg kan se er den ikke Synchronized.

At Iterator så bagved går ca. det samme som en for løkke, så synes jeg det er bedre at anvende de medbragte metoder. Men det er smag og behag.

Så vidt jeg husker er kaster Iteratoren en Exception, hvis der ændres i de bagved liggende data.
D.v.s. den beskytter ikke mod fejl, men den sørger for at de opdages, så der ikke kommer inkonsistente data.

Jeg siger heller ikke at man kun skal bruge den ved flertrådede apps, kun at jeg er tilbøjelig til at vælge den nemmeste metode - mindre tastearbejde og mindre overhead - når jeg ikke kan se en direkte gevinst.
Jeg er doven af natur, og jeg dyrker det:-))

hmm, det kan jeg nu ikke lige finde i API\'en at den skulle gøre.

Det er forresten også en ikke pæn måde at opdage tråd problemmer på, Synchronize ville nok være noget bedre, så der ganske enkelt ikke sker sådanne ting.

Hehe, jeg synes nu Iterator er nemmere end for løkken :)

En helt anden ting hvis man bruger en for løkke skulle man tage og finde ud af .size() før man laver løkken, ellers skal den beregne størrelsen for hvert gennemløb, og det giver dårlig performance.

Hvis du har ret i at den finder size() for hvert gennemløb, så har du afgjort ret.

Men hvis du kigger på http://www.eksperten.dk/spm/155294
så er der noget der tyder på at compileren gør arbejdet for dig.

Compileren kan under ingen omstændigheder gøre det, måske kan JVM\'en hvilket jeg tvivler på.

For hvad hvis size() ændrer sig, JVM\'en kan ikke bare gætte sig til om det sker eller ej.

I følge et glimrende foredrag på JavaOne sidste år, er det en vigtig ting at flytte den ud hvis man ved der ikke ændres på size under gennemløbet af for løkken.

Du har ret. Det skal jeg have i baghovedet fremover.