Newsgroup: it.comp.java
Titolo: Check Syntax

Ho provato a fare un benchmark di un operazione che avevo già provato in
Macromedia Flash.
Il risultato è che Flash ci metteva 152 ms, Java 10.
In poche parole estraggo in modo random 100 elementi tra i 400 composti da
(1 a 20)+","+(1 a 20).
In realtà il metodo non è il più veloce, ma è quello che mi da un pò più
affidibilità per il random (anche se credo sia un discorso prettamente
psicologico).
Detto questo mi piacerebbe sapere il vostro consiglio di esperti, magari per
sapere se si poveva fare qualcosa a livello di sintassi di più prestante o
più elegante ad esempio.
Code:
import java.util.*;
public class ArrTest {
 
    public static void main ( String[] args) {
        long t1=System.currentTimeMillis();
        ArrayList t_people = new ArrayList();
        ArrayList people = new ArrayList();
        int a=0;
        int b=0;
        int i=0;
        for (a=0; a<21; a++) {
            for (b=0; b<21; b++) {
                t_people.add(a+","+b);
            }
        }
        while(i<100){
            int element = (int) Math.floor(Math.random() * t_people.size());
            Object el = t_people.get(element);
            boolean pres = false;
            int j=0;
            for(j=0; j<people.size(); j++){
                if(el == people.get(j)){
                    pres=true;
                    break;
                }
 
            }
            if(!pres){
                people.add(el);
                i++;
            }
        }
        long t2=System.currentTimeMillis();
        System.out.println("Ha impiegato: "+(t2-t1));
    }
}
Grazie mille dell'attenzione.
Christian
----------------------------
     Christian Giordano
    Multimedia Developer
 
http://cgws.nuthinking.com
 --------------------------
 
www.nuthinking.com
----------------------------

 (1 a 20)+","+(1 a 20)
Ho pensato ad alcune possibilità:
----------------------inizio codice -------------------------
import java.util.*;
public class ArrTest {
  private static final int daInserire = 100; //attenzione!
                                             //deve essere <=400
    public static void main (String[] args) {
      long t1, t2;
      t1=System.currentTimeMillis();
      conBitSet();
      t2=System.currentTimeMillis();
      System.out.println("Ha impiegato: "+(t2-t1));
      t1=System.currentTimeMillis();
      conHashSet();
      t2=System.currentTimeMillis();
      System.out.println("Ha impiegato: "+(t2-t1));
      t1=System.currentTimeMillis();
      conArrayList();
      t2=System.currentTimeMillis();
      System.out.println("Ha impiegato: "+(t2-t1));
      t1=System.currentTimeMillis();
      primaImplementazione();
      t2=System.currentTimeMillis();
      System.out.println("Ha impiegato: "+(t2-t1));
    }
        private static void primaImplementazione() {
            ArrayList t_people = new ArrayList();
            ArrayList people = new ArrayList();
            int i = 0;
        for (int a = 1; a < 21; a++) {   // ho pensato che quello che volevi
          for (int b = 1; b < 21; b++) {// fosse questo perché a e b partono
            t_people.add(a + "," + b);  // da 1
          }
        }
        while (i < daInserire) {
          int element = (int) Math.floor(Math.random() * t_people.size());
          Object el = t_people.get(element);
          boolean pres = false;
          for (int j = 0; j < people.size(); j++) {
            if (el == people.get(j)) {
              pres = true;
              break;
            }
          }
          if (!pres) {
            people.add(el);
            i++;
          }
        }
      }
    private static void conBitSet() {
      ArrayList people = new ArrayList();
      BitSet inseriti = new BitSet(400);
/* chiaramente anche un array tipo:
boolean[] inseriti = new boolean[400]
farebbe la stessa cosa. Non saprei quale dei due
occupa meno spazio in memoria */
      int a,b, i=0;
      while(i<daInserire) {
        int posizione = (int) Math.floor(Math.random() * 400);
        if(!inseriti.get(posizione)) {
          inseriti.set(posizione);
          a=posizione/20;
          b=(posizione%20)+1;
          people.add(a+","+b);
          i++;
        }
      }
    }
    private static void conArrayList() {
    ArrayList people = new ArrayList();
    int i=0;
    while(i<daInserire) {
      int posizione = (int) Math.floor(Math.random() * 400);
      int a=posizione/20;
      int b=(posizione%20)+1;
      String nuova = a+","+b;
      int p;
      if((p = Collections.binarySearch(people,nuova))<0) {
        people.add(-(p+1),nuova);
        i++;
      }
    }
  }
    private static void conHashSet() {
        //a mio parere la piu' elegante
      HashSet people = new HashSet(daInserire);
      int i=0;
      while(i<daInserire) {
        int posizione = (int) Math.floor(Math.random() * 400);
        int a=posizione/20;
        int b=(posizione%20)+1;
        if(people.add(a+","+b)) i++;
      }
    }
}
--------------fine codice ---------------
probabilmente andrebbero provati ognuno nel loro Thread (non in
concorrenza) perché così danno risultati diversi che sembrano
dipendere dall'ordine con cui vengono eseguiti.
Fammi sapere che ne pensi
Ciao
Matteo

           b=(posizione%20)+1;
E così per tutti i metodi.
Ciao
Matteo

 }
Qui non capisco devo sta la verifica? forse l'HashSet non permette elementi
uguali?
A presto, Christian


 elementi uguali?
if(people.add(a+","+b))
esatto, tutte le strutture che implementano l'interfaccia Set (essendo un 
insieme) non permettono elementi uguali. Quindi add() restituisce false se 
ha sostituito un elemento, cioè se l'elemento era già presente.
Cmq la chiave della questione credo che sia il fatto che a e b possono 
essere generati sul momento in base all'intero che ne identificherebbe la 
posizione, non c'è bisogno di calcolarli tutti e poi prendere quelli utili.
Ciao
Matteo

 posizione, non c'? bisogno di calcolarli tutti e poi prendere quelli utili.
Essě... grazie mille per il tuo supporto!
