Newsgroup: it.comp.java
Titolo: Java e performance

Salve a tutti,
programmando in java sono portato a creare classi ogni volta che mi
trovo a dover utilizzare strutture di dati di più di un paio di
variabili. Programmare ad oggetti è infatti comodo ed ordinato ma mi è
venuto un dubbio che spero saprete risolvere:
premetto che sto parlando di un ambiente client/server (servlet, jsp,
ecc...) dove gli accessi contemporanei sono una componente essenziale da
considerare.
Quanto pesa in termini di prestazioni creare oggetti? Mi spiego meglio.
Se voglio creare una classe Cliente con i seguenti campi:
- nome
- cognome
- indirizzo
- numero di telefono
- CAP
- citta
- codice fiscale
ecc...
lasciando stare per un momento i vantaggi innegabili degli oggetti con
cui concordo in pieno, pesa molto di più creare un oggetto a fronte
della creazione e dell'utilizzo delle semplici variabili "slegate" e se
sì, in quale misura?
Ho notato che molti testi tralasciano questo aspetto che secondo me è
fondamentale.
Grazie e ciao.
smolps

Leggi qui, l'ho copiato da un sito non ricordo quale...
Saluti, RIccardo
Q: What other operations are surprisingly slow? 
Where do I begin? Here are a few that are most useful to know about. I 
wrote 
a timing utility that runs snippets of code in a loop, reporting the 
results 
in terms of thousands of iterations per second (K/sec) and microseconds 
per 
iteration (uSecs). Timing was done on a Sparc 20 with the JDK 1.1.4 JIT 
compiler. I note the following:  Counting down (i.e. for (int i=n; i>0; 
i--)) 
is twice as fast than counting up: my machine can count down to 144 
million 
in a second, but up to only 72 million.  Calling Math.max(a,b) is 7 
times 
slower than (a > b) ? a : b. This is the cost of a method call.  Arrays 
are 
15 to 30 times faster than Vectors. Hashtables are 2/3 as fast as 
Vectors.  
Using bitset.get(i) is 60 times slower than bits & 1 << i. This is the 
cost 
of a synchronized method call, mostly. Of course, if you want more than 
64 
bits, you can't use my bit-twiddling example. Here's a chart of times 
for 
getting and setting elements of various data structures: 
  K/sec     uSecs          Code           Operation 
=========  ======= ====================  ===========
  147,058    0.007 a = a & 0x100;        get element of int bits
      314    3.180 bitset.get(3);        get element of Bitset
   20,000    0.050 obj = objs[1];        get element of Array
    5,263    0.190 str.charAt(5);        get element of String
      361    2.770 buf.charAt(5);        get element of StringBuffer
      337    2.960 objs2.elementAt(1);   get element of Vector
      241    4.140 hash.get("a");        get element of Hashtable
      336    2.970 bitset.set(3);        set element of Bitset
    5,555    0.180 objs[1] = obj;        set element of Array
      355    2.810 buf.setCharAt(5,' ')  set element of StringBuffer
      308    3.240 objs2.setElementAt(1  set element of Vector
      237    4.210 hash.put("a", obj);   set element of Hashtable
 Java compilers are very poor at lifting constant expressions out of 
loops. 
The C/Java for loop is a bad abstraction, because it encourages 
re-computation of the end value in the most typical case. So for(int 
i=0; 
i<str.length(); i++) is three times slower than int len = str.length(); 
for(int i=0; i<len; i++)

 Q: What other operations are surprisingly slow?
.....