Newsgroup: it.comp.java
Titolo: Array

Domandina: Se ho un array di stringhe da 100 elementi ( String[] lista = new 
Stringa[100] ), ma ne inserisco solo 10, come faccio a sapere che ci sono 
solo 10 elementi ?
Grazie
-- 
Ciao by Siro            
^__^

 Grazie
Rispondo al volo (non ho sottomano un javac per provare).
IMHO ci sono tre alternative
. lista.length restituisce 10 (poco probabile, dovrebbe restituire 100)
. l'undicesimo elemento è null
. non puoi saperlo :)
Il problema potrebbe dipendere anche dalla implementazione della JVM
(dipende se "mamma Sun" l'ha scritto nelle specifiche o l'ha lasciato al 
buon cuore degli implementatori delle JVM :) )).
HTH

 Grazie
potresti incrementare un contatore ogni volta che inserisci un elemento. 
scusa se è molto banale ma sto imparando anche io java e per il momento non 
saprei dirti molto.
ciao



Ciao,
non esiste, a quanto ne so', un metodo gia' pronto per farlo...devi
quindi scrivertelo tu.
L'algoritmo (e la sua efficienza) dipende molto da come inserisci gli
elementi.
Se li inserisci dall'inizio e senza "buchi", il tutto si risolve con
qualcosa simile al seguente codice:
int counter;
for (counter=0; stringArray[counter]!=null; counter++);
Se invece ci sono dei "buchi", mi sa che te li devi contare tutti:
int counter=0;
for (int i=0; i<stringArray.length; i++)
  if (stringArray[i] != null) counter++;
Un metodo migliore e', come gia' ti suggeriva galway, quello di
mantenersi un contatore che viene incrementato ogni volta che inserisci
un nuovo elemento nell'array. Cosi' eviti di doverti ricontare gli
elementi non null ogni volta.
La soluzione migliore e' invece quella di lasciar perdere gli array e
usare una List (magari un ArrayList)...ma immagino che il problema sia
puramente "didattico".
Saluti
  Lucio
-- 
Lucio Benfante
Brainbench MVP for Java 1
http://www.brainbench.com
MyTranscript: 
http://www.brainbench.com/transcript.jsp?pid=167064

 solo 10 elementi ?
Li conti (o tutti in una volta  tieni il conteggio man mano).
Ciao,
 Stefano
----------
"X WindowSSS, teSSSoro mio... lo odieremo per SSSempre"
Bill Gollum
----------

Prova a vedere l'interfaccia List e le classi che la implementano tipo
Vector,LinkedList ecc (se non mi sbaglio, ma non ho modo di controllare
adesso la classe Vector dovrebbe avere un metodo per questo) se ha qualche
metodo che fa quello che chiedi.
Se c'č puoi ottenere un oggetto che implementa List con il metodo
Array.asList(nome dell'array);
e passarlo al costruttore dell'insieme che vuoi, ad esempio
Vector v = new Vector(Array.asList(array));

Ho controllato nella classe Vector ci sono due metodi capacity() e size().
Il primo ti restituisce la capacità del vettore e perciò la lunghezza mentre
il secondo restituisce il numero di elementi inseriti.
Oltrettutto penso che se hai un array con alcune posizioni vuote, quando ne
ricavi il vettore, nell'inserimento il vettore li salta e nel vettore non
hai spazi vuoti così puoi contare il numero effettivo di elementi.



No! ...perche' mai dovrebbe saltarli? ...sono anch'essi elementi
dell'array, e quindi perche' non dovrebbero diventare elementi del Vector?
...si ricordi che cio' che viene trattato sono i reference agli
oggetti...quindi gli array non sono array di oggetti, ma array di
reference ad oggetti...quindi null e' un valore perfettamente
plausibile...un reference a niente (vabbe' non e' proprio
cosi'...perdonatemi).
Comunque, gli array in Java vengono tutti allocati dinamicamente (come
praticamente tutto in Java)...quindi nel momento in cui li creo dovrei
poter sapere quanti elementi ci devo inserire. Se non lo so, devo usare
le Collection.
Inoltre non e' proprio vero che capacity restituisce la lunghezza del
vettore: e' vero che restituisce la sua attuale capacita' (e quindi la
lunghezza attuale dell'array che internamente viene usato per memorizzare
gli elementi), ma questa capacita' viene aumentata mano a mano che
occorre.


 occorre.
Anche qui mi sono espresso male, ma non stavo cercando di spiegargli tutti i
meccanismi interni di java :-), ho detto capacità e poi lunghezza per
cercare di spiegare più semplicemente.
Inoltre, forse ti confondi con gli ArrayList quando dici che la capacità
viene incrementata mano a mano che serve.
Ciao

 incrementata mano a mano che serve. Ciao
...direi proprio di no. :-)
...dalla documentazione di Vector:
"Each vector tries to optimize storage management by maintaining a
 capacity and a capacityIncrement. The capacity is always at least as
 large as the vector size; it is usually larger because as components are
 added to the vector, the vector's storage increases in chunks the size of
 capacityIncrement. An application can increase the capacity of a vector
 before inserting a large number of components; this reduces the amount of
 incremental reallocation."


 ...dalla documentazione di Vector:
Qui ho torto marcio, un professore me l'aveva elencato come una delle
differenze tra Vector ed ArrayList ed io mi sono fidato senza controllare.
Ciao

 
Ah, 'sti professori...
Fondamentalmente la differenza e' che Vector e' una collection "legacy", 
in realta' non esiste piu' (in senso non letterale) ed e' stata 
reimplementata con le nuove Collection API solo per compatibilita' verso 
il passato. Prevede un accesso sincronizzato, mentre le nuove collection 
API, compreso dunque l'Arraylist, sono tutte di base non-sincronizzate 
(c'e' un wrapper per renderle tali).
uL



Ciao Ugo,
...ricordati che (salutariamente) sei professore anche tu...guarda che ti
ho visto in TV a "sparlare" di HTTP connectionless e connectionfull
...peccato che non sia riuscito a registrarti :-)


Correggo:
Non è Array.asList(...) ma Arrays.asList(...)

Con removeAll() il problema è risolto, è dispendioso ma diciamo che è solo a
livello di curiosità.
Ciao, ho letto che probabilmente andrai al Webb.it, magari ci si vede
allora.
package test;
import java.util.*;
public class VectorTest{
 public VectorTest(){}
 public static void main(String[] args){
  String[] a={"a","b",null,"c","d"};
  Vector v=new Vector(Arrays.asList(a));
  System.out.println("v1c"+v.capacity());
  System.out.println("v1s"+v.size());
  System.out.println(v);
  v.removeAll(Collections.nCopies(v.capacity(),null));
  System.out.println(v);
 }
}

Te l'avevo detto che era stato il massimo dei corsi :-)
Ciao Ugo

 
Si, Connectionfull me lo sono inventato li per li', era 
Connection-Oriented. Poi i puristi di TCP mi hanno anche fatto notare 
che HTTP e' considerato Connection-Oriented, visto che e' poggiato su TCP.
Indagando un po' su Internet, sembra ci sia una diatriba terminologica: 
a seconda da dove lo si veda, http puo' o meno essere considerato 
connectionless: comunque lo e' per chi lavora server side.
Ah, le prove delle malefatte le ho io, in originale :)
uL

 connectionless: comunque lo e' per chi lavora server side.
http 1.0, ovviamente. 1.1 ha il keepalive. :)
uL

 allora.
con piacere...spero di riuscire ad organizzare i miei impegni per
andarci.



Io spero di no... e' Sabato e Domenica. Se non riuscissi a scansarlo 
(molto probabile), ci si vede li'
ciao
uL



...comunque penso che sara' divertente...anche se Padova non e' certo un
bel posto per passarci l'estate :-)


 buon cuore degli implementatori delle JVM :) )).
Esistono delle specifiche, dovrebbe essere uguale per tutte
le JVM.
Andrea

Grazie a tutti per le risposte.
Credo che la soluzione migliore per il mio problema, sia usare la classe 
Vector, ma darò un'occhiata anche ad Arraylist, che non conoscevo.
