Question

J'ai six variables de chaîne dites str11, str12, str13, str21, str21 et str23.

Je dois comparer la combinaison de ces variables.

Les combinaisons que je dois vérifier sont str11 - str12 - str13 en tant que groupe et str21 - str22 - str23 en tant qu'autre groupe. Je dois comparer ces deux groupes.

Maintenant, je ne comprends plus quelle méthode utiliser pour la comparaison?

Puis-je ajouter des chaînes du même groupe et comparer, ce qui n'est qu'une comparaison    dire (str11 append str12 append str13) eqauls (str21 append str22 append str23)

Ou

Dois-je choisir 3 comparaisons individuelles?

if( str11 equals str21 ) {

    if( str12 equals str22 ) {

        if( str13 equals str23 ) {

        }

    }

}

Quel est le facteur de performance qui me coûte en raison de la longueur de la chaîne lorsque je compare des chaînes? Supposons que toutes les chaînes ont la même longueur (environ).

Était-ce utile?

La solution

Je & # 8217; d teste individuellement.

Is & # 8220; AB & # 8221; & # 8220; CD & # 8221; & # 8220; EF & # 8221; égal à & # 8220; ABC & # 8221; & # 8220; DE & # 8221; & # 8220; F & # 8221;?

Moi ne pense pas.

P.S. Si tel est le cas, c’est un cas TRÈS particulier, et si vous décidez de le coder de cette façon (à titre de comparaison concaténée), commentez-le.

Autres conseils

Diviser la comparaison en trois déclarations if n'est certainement pas nécessaire. Vous pouvez aussi simplement faire un AND avec vos comparaisons, par exemple

if (  str11 equals str21
   && str12 equals str22
   && str13 equals str23) ...

Vos noms de variable indiquent une odeur majeure de code. Cela ressemble au lieu d'avoir six variables, vous devriez plutôt avoir deux tableaux, chacun contenant trois chaînes. En d’autres termes, quelque chose comme cela aurait été beaucoup mieux au début:

String[][] strs = new String[2][3];
strs[0][0] = str11;
strs[0][1] = str12;
...

Il se peut que, selon l'endroit où vous avez obtenu les six chaînes, vous n'avez pas besoin de le faire manuellement juste avant la comparaison, mais vous pouvez probablement transmettre vos arguments dans un format plus convivial.

Si vous souhaitez le faire en comparant les tableaux des objets chaîne et que vous utilisez Java 1.5 ou une version ultérieure, n’oubliez pas que vous avez accès aux méthodes java.util.Arrays.equals () pour l’égalité des tableaux. Utiliser autant que possible les méthodes de la bibliothèque est un excellent moyen d’éviter des efforts supplémentaires pour réinventer la roue et les erreurs d’implémentation possibles (les deux implémentations soumises jusqu’à présent ont des bogues, par exemple).

L’itinéraire exact que vous prenez dépend probablement du domaine pour lequel vous écrivez. Si votre problème particulier vous oblige à toujours comparer 3-uplets, écrire le code pour comparer explicitement des groupes de trois chaînes ne serait pas une si bonne idée. comme il serait probablement plus immédiatement compréhensible que le code comparant des tableaux de longueur arbitraire. (Si vous vous rendez sur cette route, alors nous entendons certainement un seul if () conditionnel avec & amp; & amp; & amp; & amp; & nbsp; au lieu de si imbriqué, comme Adam Bellaire l’a démontré).

En général cependant, vous aurez un bloc de code beaucoup plus réutilisable si vous le configurez pour fonctionner avec des tableaux de longueur arbitraire.

L'association des chaînes et la comparaison ne fonctionneront pas. Par exemple, les chaînes 1 et 2 peuvent être vides et la chaîne 3 peut contenir "gorps", tandis que la chaîne 4 contient "gorps". et 5 et 6 sont vides. Une comparaison des résultats annexés renverrait true, bien que ce soit un faux positif. Vous devrez créer un délimiteur dont vous vous garantissez qu'il ne serait contenu dans aucune chaîne pour que cela fonctionne, et qui pourrait devenir compliqué.

Je voudrais juste faire la comparaison comme vous le faites. Il est lisible et simple.

L'itération sur un grand caractère [] est probablement plus rapide que l'itération sur n chaîne séparée d'une longueur totale égale. Cela est dû au fait que les données sont très locales et que la CPU dispose d’un temps facile pour la pré-extraction.

Cependant, lorsque vous concaténez plusieurs chaînes en Java, vous utiliserez StringBuilder / Buffer, puis vous reconvertirez i en String dans plusieurs cas. Cela entraînera une augmentation de l'allocation de mémoire en raison du fonctionnement de SB.append () et du fait que Java String est immuable, ce qui peut créer un goulot d'étranglement mémoire et ralentir considérablement votre application.

Je recommanderais de garder les chaînes telles quelles et de faire une comparaison séparée. Le gain de performance dû à un caractère plus long [] est probablement bien inférieur aux problèmes que vous pouvez rencontrer avec un taux d’allocation plus élevé.

Avec tout le respect: je pense que votre code et votre question sent non seulement un peu, mais pue presque (grand smiley ici).

1) les noms de variables indiquent qu’il existe réellement des vecteurs de chaîne; comme déjà mentionné
2) la question des comparaisons individuelles vs une comparaison concaténée soulève la question de savoir comment vous définissez l'égalité de vos tuples de chaînes; aussi déjà mentionné.

Mais ce qui me frappe le plus:

3) Pour moi, cela ressemble à un cas typique d’optimisation prématurée. et compter les cycles du processeur au mauvais endroit.

Si vous vous souciez vraiment de la performance, oubliez le coût de 3 comparaisons individuelles par rapport à une seule comparaison. Au lieu de cela:

Qu'en est-il de la surcharge créée par la création de deux chaînes concaténées?

  (str11 + str12 + str13) = (str21 + str22 + str23)

Analysons ce que w.r.t. au gestionnaire de mémoire et aux opérations à effectuer. Au niveau bas, cela se traduit par 4 allocations de mémoire supplémentaires, 2 strcpas supplémentaires et 4 autres strcat ou strcpy supplémentaires (en fonction de la manière dont la VM le fait; mais la plupart utiliseraient une autre strcpy). Ensuite, une seule comparaison est appelée, qui ne compte pas d'abord les caractères utilisant strlen; à la place, il connaît la taille à l'avance (si l'en-tête de l'objet inclut également le nombre de caractères, ce qui est probable) ou s'exécute simplement jusqu'à 0 octet. Cela s'appelle une fois contre 3 fois. Le nombre réel de caractères à comparer est à peu près identique (oubliez les 0 octets supplémentaires). Cela nous laisse avec 2 appels supplémentaires à strcmp (quelques nS), par rapport à la surcharge que j'ai décrite ci-dessus (quelques uS). Si nous additionnons les frais généraux de récupération du GC (0 allocation contre 4), je dirais que votre "optimisé" La solution peut facilement être 100 à 1000 fois plus lente que les 3 strcmps!

Avis supplémentaire: Théroriquement, JITter pourrait optimiser tout ou partie de ce code et générer le code suggéré par Adam Bellaire, mais je doute qu'un développeur de JIT se préoccupe d'optimiser ce code. En passant, les routines du système (comme les opérations sur les chaînes) du système sont généralement BEAUCOUP plus rapides que le codage manuel, aussi ne commencez pas à boucler vous-même des caractères individuels.

Je voudrais ajouter les deux groupes dans deux tableaux, puis faire une boucle sur les tableaux pour comparer les chaînes individuelles de ce tableau. Un bon exemple est déjà cité dans les réponses données par Markus Lausberg.

Je ne me soucierais pas des coûts de performance. Il suffit de l'écrire de la manière la plus lisible possible. Le compilateur Java est très bon en optimisation des performances.

Exemple de méthode:

    public boolean compareGroups(String[] group1, String[] group2){
    if (group1.length != group2.length ){
        return false;
    }

    for (int i = 0; i < group1.length; i++) {
        if (!group1[i].equals(group2[i])){
            return false;
        }
    }

    return true;
}

Et appeler la méthode est bien sûr simple:

        String[] group1 = new String[]{"String 1", "String 2", "String 3"};
    String[] group2 = new String[]{"String 1", "String 2", "String 3"};

    boolean result = compareGroups(group1, group2);

Je voudrais utiliser le moyen simple

exécution dynamique sur tous les éléments de tableau des deux tableaux.

            boolean isEqual = true;
            for(int n = 0;n<str1.length;++n){
                isEqual &= str1[n].equals(str2[n]);
            }

            return isEqual;
Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top