Scanner vs StringTokenizer vs Chaîne.Split

J'ai juste appris à propos de Java Scanner classe et maintenant je me demande comment il se compare/rivalise avec la StringTokenizer et de la Corde.Split. Je sais que le StringTokenizer et de la Corde.Split seulement le travail sur les Cordes, alors, pourquoi voudrais-je utiliser le Scanner pour une Chaîne de caractères? Est Scanner uniquement destiné à être one-stop-shopping pour la crève?

InformationsquelleAutor Dave | 2009-03-27

234

Ils sont essentiellement de chevaux pour les cours.
- Scanner est conçu pour les cas où vous avez besoin d'analyser une chaîne de caractères, en tirant des données de différents types. Il est très souple, mais sans doute ne vous donne pas le plus simple API pour obtenir simplement un tableau de chaînes de caractères séparées par une expression particulière.
- String.split() et Pattern.split() vous donner une syntaxe facile à utiliser pour faire le dernier, mais c'est essentiellement tout ce qu'ils font. Si vous souhaitez analyser le résultant de chaînes, ou de modifier le séparateur à mi-chemin par le biais de selon un pion, ils ne seront pas vous aider avec ça.
- StringTokenizer est encore plus restrictive que String.split(), et aussi un peu fiddlier à utiliser. Il est essentiellement conçu pour retirer les jetons délimité par des sous-chaînes. En raison de cette restriction, il est deux fois plus rapide que String.split(). (Voir mon comparaison de String.split() et StringTokenizer.) Il est également antérieure à les expressions régulières de l'API, dont String.split() est une partie.
Vous pourrez observer de mes timings que String.split() peut encore marquer des milliers de chaînes de caractères dans les quelques millisecondes sur une machine typique. En outre, il a l'avantage sur StringTokenizer qu'il vous donne le résultat sous la forme d'un tableau de chaîne, ce qui est généralement ce que vous voulez. À l'aide d'un Enumeration, comme prévu par la StringTokenizer, est trop "syntaxiquement pointilleux" la plupart du temps. De ce point de vue, StringTokenizer est un peu du gaspillage de l'espace de nos jours, et vous pouvez aussi bien l'utiliser juste String.split().
- Oui, très perspicace!
- Serait également intéressant de voir les résultats du Scanner sur les mêmes tests que vous avez exécuté sur la Chaîne.Split et StringTokenizer.
- M'a donné une réponse à une autre question: "pourquoi est-utilisation de StringTokenizer découragé, comme indiqué dans l'API Java notes?". À partir de ce texte, il semble que la réponse serait "car les chaînes de caractères.split() est assez rapide".
- Donc, est StringTokenizer assez bien obsolète maintenant?
- Oui, assez bien.
- ce qu'il faut utiliser à la place de celui-ci? Scanner?
- Comme je le mentionne ci-dessus, pour la plupart des fins, vous pouvez utiliser des chaînes de caractères.split[] dans le même but que StringTokenizer.
- StringTokenizer est considéré comme obsolète, mais je l'utilise encore de temps en temps pour analyser tout simplement parce que c'est la méthode la plus simple pour les types de l'analyse que je fais. Si ils finissent par tomber complètement, je vais devoir revenir en arrière et réécrire le code, mais il est obsolète depuis des éons, ne semble pas aller loin. 🙂
- Je réalise que c'est une réponse à une vieille question, mais si j'ai besoin de diviser un énorme flux de texte en jetons à la volée, n'est-ce pas StringTokenizer toujours mon meilleur pari, car String.split() va tout simplement à court de mémoire?
- Je ne suis pas sûr que je comprends très bien: les deux StringTokenizer et de la Corde.split() nécessitera l'ensemble de la séquence en mémoire. Pour le fractionnement à la volée, si vous êtes justing fractionnement sur un caractère particulier, c'est probablement aussi facile que quelque chose de juste "manivelle" les choses. Pour les plus complexes fractionnement des critères, modèle.split() peut prendre un arbitraire CharSequence.
- Désolé pour la réponse tardive. J'ai pensé StringTokenizer accepte un flux d'entrée. Doit avoir été pensée de Scanner. Encore, je ne peux penser à une bonne utilisation de StringTokenizer vs split: si vous passez returnDelims = true, vous obtenez des délimiteurs, que vous ne pouvez pas faire avec split.
InformationsquelleAutor Neil Coffey
57

Commençons par éliminer StringTokenizer. Il se fait vieux et n'est même pas en charge les expressions régulières. Ses états de documentation:

StringTokenizer est un héritage de la classe qui est retenu pour des raisons de compatibilité, même si son utilisation est déconseillée dans le nouveau code. Il est recommandé à toute personne à la recherche de cette fonctionnalité utiliser le split méthode de String ou la java.util.regex paquet.

Donc, nous allons jeter tout de suite. Qui laisse split() et Scanner. Quelle est la différence entre eux?

Pour une chose, split() simplement renvoie un tableau, ce qui le rend facile à utiliser une boucle foreach:
```
for (String token : input.split("\\s+") { ... }
```
Scanner est construit plus comme un ruisseau:
```
while (myScanner.hasNext()) {
    String token = myScanner.next();
    ...
}
```
ou
```
while (myScanner.hasNextDouble()) {
    double token = myScanner.nextDouble();
    ...
}
```
(Il a un assez grand API, donc ne pense pas que c'est toujours limitées à des choses simples.)

Ce volet de style de l'interface peut être utile pour l'analyse des fichiers de texte simple ou de console d'entrée, lorsque vous n'avez pas (ou ne pouvez pas faire) tous les commentaires avant de commencer à analyser.

Personnellement, la seule fois où je me souviens à l'aide de Scanner est pour les projets d'école, lorsque j'ai eu pour obtenir la saisie de l'utilisateur à partir de la ligne de commande. Il fait ce genre d'opération facile. Mais si j'ai un String que je veux séparer, c'est presque une évidence pour aller avec split().
- StringTokenizer est 2x plus rapide que la Chaîne.split(). Si vous n'avez pas BESOIN d'utiliser des expressions régulières, NE PAS!
- J'ai juste utilisé Scanner pour détecter les caractères de nouvelle ligne dans un String. Depuis de caractères de nouvelle ligne peut varier d'une plateforme à une autre (regardez Pattern's javadoc!) et chaîne d'entrée n'est PAS garanti pour les rendre conformes à System.lineSeparator(), je trouve Scanner plus adapté car il sait déjà ce que la nouvelle ligne de caractères à rechercher lors de l'appel de nextLine(). Pour String.split je vais avoir à nourrir dans la bonne regex modèle pour détecter la ligne de séparateurs, de laquelle je ne trouve pas stockée dans un emplacement standard (le mieux que je puisse faire est de le copier à partir de la Scanner source de la classe).
InformationsquelleAutor Michael Myers
9

StringTokenizer était toujours là. Il est le plus rapide de tous, mais l'énumération de l'idiome pourrait ne pas sembler aussi élégant que les autres.

split est venu à l'existence sur le JDK 1.4. Plus lent que le générateur de jetons, mais plus facile à utiliser car il peut être appelé à partir de la classe String.

Scanner est venu pour être sur JDK 1.5. C'est la plus flexible et la remplit de longue date de l'écart sur l'API Java pour soutenir un équivalent de la célèbre Cs fonction scanf famille.
- Correction rapide: Scanner a été introduit dans le JDK 1.5.
- Vous avez raison!... mieux les corriger.
InformationsquelleAutor H Marcelo Morales
6

Split est lent, mais pas aussi lent que Scanner. StringTokenizer est plus rapide que de le découper. Cependant, j'ai trouvé que je pouvais obtenir le double de la vitesse, par la négociation d'une certaine souplesse, pour obtenir un speed-boost, ce que j'ai fait JFastParser https://github.com/hughperkins/jfastparser

Test sur une chaîne de caractères contenant un million de doubles:
```
Scanner: 10642 ms
Split: 715 ms
StringTokenizer: 544ms
JFastParser: 290ms
```
- Certains Javadoc aurait été sympa, et si vous voulez analyser autre chose que des données numériques?
- Eh bien, il est conçu pour la vitesse, pas de beauté. C'est assez simple, il suffit de quelques lignes, de sorte que vous pouvez ajouter un peu plus d'options pour l'analyse de texte si vous le souhaitez.
InformationsquelleAutor Hugh Perkins
5

Si vous avez une Chaîne de caractères de l'objet que vous souhaitez marquer, la faveur à l'aide de la Chaîne de split la méthode au cours d'un StringTokenizer. Si vous êtes à l'analyse des données de texte à partir d'une source à l'extérieur de votre programme, comme à partir d'un fichier, ou de l'utilisateur, c'est là un Scanner est très pratique.
- Juste comme ça, pas de justification, pas de raison?
InformationsquelleAutor Bill the Lizard
4

Chaîne.split semble être beaucoup plus lent que StringTokenizer. Le seul avantage avec split est que vous obtenez un tableau des jetons. Aussi vous pouvez utiliser des expressions régulières dans split.
org.apache.commons.lang.StringUtils a une méthode de fractionnement qui fonctionne beaucoup plus rapide que l'un des deux viz. StringTokenizer ou Chaîne.split.
Mais l'utilisation du PROCESSEUR pour tous les trois, est presque le même. Nous avons donc aussi besoin d'une méthode qui est moins consommateur d'UC, dont je ne suis toujours pas capable de le trouver.
- Cette réponse est un peu absurde. Vous dites que vous êtes à la recherche de quelque chose qui est plus rapide mais moins "UC". Tout programme est exécuté par le PROCESSEUR. Si un programme n'utilise pas de votre CPU à 100%, alors il doit être en attente de quelque chose d'autre, comme I/O. Qui ne devrait jamais être un problème lors de la discussion de la chaîne de segmentation en unités, sauf si vous êtes en train de faire un accès direct au disque (ce qui nous a notamment ne sont pas en train de faire ici).
InformationsquelleAutor Manish
4

J'ai récemment fait quelques expériences sur la mauvaise performance de la Chaîne.split() est très sensible aux performances des situations. Vous pouvez trouver cela utile.

http://eblog.chrononsystems.com/hidden-evils-of-javas-stringsplit-and-stringr

L'essentiel est que Chaîne de caractères.split() compile un modèle d'Expression Régulière à chaque fois et peut donc ralentir votre programme, par rapport à si vous utilisez un fichier de Modèle de l'objet et de l'utiliser directement pour fonctionner sur une Chaîne.
- En Fait La Chaîne.split() n'est pas toujours compiler le modèle. Regardez le code source si 1.7 java, vous verrez qu'il y a un contrôle si le modèle est un caractère unique et pas une fuite de l'un, il se divise, la chaîne sans regexp, il devrait donc être assez rapide.
InformationsquelleAutor pdeva

Pour les scénarios par défaut je dirais Modèle.split (), mais si vous avez besoin d'un maximum de performance (en particulier sur Android, toutes les solutions que j'ai testé sont assez lent) et vous avez seulement besoin de diviser par un seul char que j'utilise maintenant ma propre méthode:

public static ArrayList<String> splitBySingleChar(final char[] s,
        final char splitChar) {
    final ArrayList<String> result = new ArrayList<String>();
    final int length = s.length;
    int offset = 0;
    int count = 0;
    for (int i = 0; i < length; i++) {
        if (s[i] == splitChar) {
            if (count > 0) {
                result.add(new String(s, offset, count));
            }
            offset = i + 1;
            count = 0;
        } else {
            count++;
        }
    }
    if (count > 0) {
        result.add(new String(s, offset, count));
    }
    return result;
}

Utiliser "abc".toCharArray() pour obtenir le char tableau pour une Chaîne de caractères. Par exemple:

String s = "     a bb   ccc  dddd eeeee  ffffff    ggggggg ";
ArrayList<String> result = splitBySingleChar(s.toCharArray(), ' ');

InformationsquelleAutor Simon Heinen

Une différence importante est que les deux Cordes.split() et le Scanner peuvent produire les cordes à vide, mais StringTokenizer est jamais.

Par exemple:

String str = "ab cd  ef";

StringTokenizer st = new StringTokenizer(str, " ");
for (int i = 0; st.hasMoreTokens(); i++) System.out.println("#" + i + ": " + st.nextToken());

String[] split = str.split(" ");
for (int i = 0; i < split.length; i++) System.out.println("#" + i + ": " + split[i]);

Scanner sc = new Scanner(str).useDelimiter(" ");
for (int i = 0; sc.hasNext(); i++) System.out.println("#" + i + ": " + sc.next());

De sortie:

//StringTokenizer
#0: ab
#1: cd
#2: ef
//String.split()
#0: ab
#1: cd
#2: 
#3: ef
//Scanner
#0: ab
#1: cd
#2: 
#3: ef

C'est parce que le délimiteur de Chaîne de caractères.split() et d'un Scanner.useDelimiter() n'est pas seulement une chaîne de caractères, mais une expression régulière. Nous pouvons remplacer le séparateur ", "avec" +" dans l'exemple ci-dessus pour les faire se comporter comme StringTokenizer.

InformationsquelleAutor John29

-6

Chaîne.split() fonctionne très bien, mais cela a ses limites, comme si vous vouliez de découper une chaîne comme indiqué ci-après, sur simple ou double pipe (|) symbole, il ne fonctionne pas. Dans cette situation, vous pouvez utiliser StringTokenizer.

ABC|IJK
- Actuellement, vous pouvez diviser votre exemple avec juste de "l'ABC|IJK".split("\\|");
- "ABC||DEF||".split("\\|") ne fonctionne pas vraiment bien car elle ignore le suivi de deux valeurs vides, ce qui rend l'analyse plus comlicated qu'elle ne devrait l'être.
InformationsquelleAutor Mujahid shaik

Vous devez vous connecter pour publier un commentaire.