Differenza tra l'utilizzo di StringTokenizer e String.split()?

Question

Sto usando la classe String[] split(String) della classe String per dividere qualsiasi stringa per un determinato delimitatore e ha funzionato correttamente.

Tuttavia, ora è previsto un ri-fattore della stessa logica con StringTokenizer. Ma quali sono le differenze e i vantaggi dell'usare l'uno sull'altro.

Inoltre, sento che String[] restituito da split() in una singola chiamata è un'opzione molto efficiente rispetto all'utilizzo degli oggetti della classe StringTokenizer.

Answer 1

->String.split() e Pattern.split() forniscono una sintassi semplice per eseguire quest'ultima, ma in sostanza è tutto ciò che fanno. Se si desidera analizzare le stringhe risultanti o modificare il delimitatore a metà a seconda di un particolare token, non ti aiuteranno in questo modo.

->StringTokenizer è ancora più restrittivo di String.split() e anche un po 'più fugace da usare. È essenzialmente progettato per estrarre token delimitati da sottostringhe fisse. A causa di questa restrizione, è circa il doppio della velocità di String.split(). (Vedi il mio comparison of String.split() and StringTokenizer). È anche precedente all'API delle espressioni regolari, di cui String.split() è una parte.

Noterete dai miei orari che String.split() può ancora tokenare migliaia di stringhe in pochi millisecondi su una macchina tipica. Inoltre, ha il vantaggio rispetto a StringTokenizer che ti dà l'output come array di stringhe, che di solito è ciò che desideri. L'uso di uno Enumeration, come previsto da StringTokenizer, è troppo "sintatticamente pignolo" la maggior parte delle volte. Da questo punto di vista, lo StringTokenizer è un po 'uno spreco di spazio al giorno d'oggi, e si può anche solo usare String.split().

risposta da questo link

Answer 2

Date un'occhiata al JavaDocs

StringTokenizer è una classe un'eredità che viene mantenuta per la compatibilità ragioni, anche se il suo uso è sconsigliato in nuovo codice. Si consiglia di che tutti coloro che cercano questa funzionalità utilizzino il metodo split di String o il pacchetto java.util.regex.

Il seguente esempio illustra come il metodo String.split può essere utilizzato per suddividere una stringa in token sue fondamentali:

String[] result = "this is a test".split("\\s"); 
for (int x=0; x<result.length; x++) 
    System.out.println(result[x]); 

Answer 3

String#split accetta un'espressione regolare se StringTokenizer solo accetta un String da cui dividerà la stringa. Si dovrebbe sempre attenersi allo String#split, è più robusto di StringTokenizer.

Answer 4

Leggi this

StringTokenizer è una classe un'eredità che viene mantenuta per ragioni di compatibilità, anche se il suo uso è sconsigliato in nuovo codice. Si raccomanda che chiunque cerchi questa funzionalità utilizzi il metodo split di String o il pacchetto java.util.regex.

Answer 5

http://docs.oracle.com/javase/6/docs/api/java/util/StringTokenizer.html dicono:

StringTokenizer è una classe un'eredità che viene mantenuta per ragioni di compatibilità, anche se il suo uso è sconsigliato in nuovo codice. Si raccomanda che chiunque cerchi questa funzionalità utilizzi il metodo split di String o il pacchetto java.util.regex.

Quindi direi, non cambiarlo e mostrare quella linea alla persona che ha consigliato di rifarlo. Forse hanno vecchie informazioni o un altro buon motivo per dirlo.

Answer 6

Ecco una risposta di collegamento (dal mio punto di vista) la questione: http://lavnish.blogspot.com/2008/05/stringsplit-vs-stringtokenizer.html

Answer 7

Ho il seguente programma,

La stringa "X" è una linguetta separati 12s34;

public class Testoken { 
     public static void main(String[] args) { 
      String x = "1 2 s  3   4 "; 
      StringTokenizer st = new StringTokenizer(x,"\t"); 
      int i = 0; 
      while(st.hasMoreTokens()){ 
       System.out.println("token-->"+st.nextToken());    
       i++; 
      } 
      System.out.println("i-->"+i);//elements from tokenizer 
      String [] a = x.split("\t"); 
      System.out.println("length--->"+a.length); 
      for(int y = 0;y<a.length;y++){ 
      System.out.println("value-->"+a[y]);//elements from split 
      } 
     } 
    } 





Output: 

token-->1 
token-->2 
token-->s 
token-->3 
token-->4 
i-->5 
length--->8 
value-->1 
value-->2 
value-->s 
value--> 
value-->3 
value--> 
value--> 
value-->4