String-Vergleich:Einzelvergleich vs. angehängter String-Vergleich

Question

Ich habe sechs String-Variablen, sagen wir str11, str12, str13, str21, str21 und str23.

Ich muss die Kombination dieser Variablen vergleichen.

Die Kombinationen, die ich überprüfen muss, sind str11 – str12 – str13 als eine Gruppe und str21 – str22 – str23 als andere Gruppe.Ich muss diese beiden Gruppen vergleichen.

Jetzt bin ich verwirrt, welche Methode soll ich zum Vergleich verwenden?

Kann ich Strings der gleichen Gruppe anhängen und vergleichen, das ist nur ein Vergleich sagen ( str11 append str12 append str13 ) eqauls ( str21 append str22 append str23 )

Oder

Sollte ich einzelne 3 Vergleiche anstreben?

if( str11 equals str21 ) {

    if( str12 equals str22 ) {

        if( str13 equals str23 ) {

        }

    }

}

Was ist der Leistungsfaktor, der mich aufgrund der String-Länge kostet, wenn ich einen String-Vergleich durchführe?Nehmen wir an, dass alle Zeichenfolgen (ungefähr) gleich lang sind.

Answer 1

Ich würde individuell testen.

Ist „AB“ „CD“ „EF“ gleich „ABC“ „de“ „F“?

Ich denkt nicht.

PS Wenn es so ist, dann ist es ein ganz besonderer Fall, und wenn Sie sich entscheiden, dies so zu codieren (als verketteter Vergleich), dann kommentieren Sie die Hölle heraus.

Answer 2

Die Aufteilung des Vergleichs in drei, wenn Aussagen definitiv nicht erforderlich sind. Sie können auch einfach und mit Ihren Vergleiche machen, z. B.

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

Answer 3

Ihre Variablennamen zeigen einen großen Codegeruch an. Es klingt so, als hätten Sie statt sechs Variablen zwei Arrays mit jeweils drei Saiten. Mit anderen Worten, so etwas wäre anfangs viel besser gewesen:

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

Die Chancen stehen gut, dass Sie dies nicht unmittelbar vor dem Vergleich manuell tun müssen, sondern dies nicht manuell tun müssen, sondern wahrscheinlich in einem Format, das freundlicher ist, in Ihren Argumenten passieren kann.

Wenn Sie dies tun möchten, indem Sie Arrays der String -Objekte vergleichen und Java 1.5 oder höher verwenden, denken Sie daran, dass Sie Zugriff auf die Methoden java.util.arrays.equals () für die Array -Gleichheit haben. Die Verwendung von Bibliotheksmethoden so weit wie möglich ist eine großartige Möglichkeit, zusätzliche Anstrengungen zu vermeiden, die das Rad neu erfinden, und mögliche Implementierungsfehler (beide übermittelten Implementierungen haben beispielsweise bisher Fehler).

Die genaue Route, die Sie wahrscheinlich einschlagen, hängt von der Domain ab, für die Sie schreiben - wenn Ihr spezielles Problem erforderlich ist, dass Sie immer 3 -Tupel vergleichen müssen, wäre es keine so gute Idee, den Code zu schreiben, um Gruppen von drei Zeichenfolgen zu vergleichen Wahrscheinlich unmittelbar verständlicher sein als Code, der Arrays der willkürlichen Länge verglichen. (Wenn Sie diesen Weg gehen, dann haben wir auf jeden Fall eine einzelne wenn () mit && anstelle von verschachtelten If -Blöcken, wie Adam Bellaire demonstrierte).

Im Allgemeinen haben Sie jedoch einen viel wiederkehrbaren Codeblock, wenn Sie ihn für die Arbeit mit Arrays von willkürlicher Länge einrichten.

Answer 4

Die gemeinsamen Anhänge der Saiten und des Vergleichs funktioniert nicht. Zum Beispiel könnten die Saiten 1 und 2 leer sein und String 3 "Gorps" enthalten, während String 4 "Gorps" und 5 und 6 leer sind. Ein Vergleich der angehängten Ergebnisse würde zurückkehren, obwohl dies ein falsches Positiv wäre. Sie müssten sich einen Trennzeichen einfallen lassen, den Sie garantieren würden, wenn Sie in keiner String enthalten sind, damit dies funktioniert, und das könnte chaotisch werden.

Ich würde einfach den Vergleich so machen, wie Sie es tun. Es ist lesbar und unkompliziert.

Answer 5

Die Iteration über einen großen Char [] ist wahrscheinlich schneller als die Iteration über n separate Zeichenfolge einer Gesamtlänge. Dies liegt daran, dass die Daten sehr lokal sind und die CPU eine leichte Zeit hat, Daten vorzubeugen.

Wenn Sie jedoch mehrere Zeichenfolgen in Java verkettet, verwenden Sie StringBuilder/Puffer und konvertieren dann in mehreren Fällen in eine Zeichenfolge. Dies führt zu einer erhöhten Speicherzuweisung, da SB.Append () funktioniert und die Java -Zeichenfolge unveränderlich ist, was wiederum einen Speicher Engpass erzeugen und Ihre Anwendung erheblich verlangsamen kann.

Ich würde empfehlen, die Saiten so zu halten und einen separaten Vergleich durchzuführen. Der Leistungsgewinn aufgrund eines längeren Chars [] ist höchstwahrscheinlich weitaus geringer als die Probleme, mit denen Sie mit der höheren Allokationsrate laufen können.

Answer 6

Mit allem Respekt:Ich denke, Ihr Code und Ihre Frage riechen nicht nur ein wenig, sondern fast (großer Smiley hier).

1) Die Variablennamen weisen darauf hin, dass tatsächlich String-Vektoren vorhanden sind.wie bereits erwähnt
2) die Frage des individuellen Vergleichs vs.Ein verketteter Vergleich wirft die Frage auf, wie Sie die Gleichheit Ihrer String-Tupel definieren.auch schon erwähnt.

Aber was mir am meisten auffällt:

3) Für mich sieht das nach einem typischen Fall von „vorzeitiger Optimierung“ und Zählung der CPU-Zyklen an der falschen Stelle aus.

Wenn Ihnen die Leistung wirklich am Herzen liegt, vergessen Sie die Kosten für drei Einzelvergleiche gegenüber einem einzigen Vergleich.Stattdessen:

Wie wäre es mit dem zusätzlichen Aufwand, der durch die Erstellung zweier verketteter Zeichenfolgen entsteht?

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

Lassen Sie uns das bzgl.an den Speichermanager und auszuführende Vorgänge.Auf der unteren Ebene bedeutet dies vier zusätzliche Speicherzuweisungen, zwei zusätzliche Strcpys und entweder weitere vier zusätzliche Strcats oder Strcpys (abhängig davon, wie die VM dies tut).aber die meisten würden andere strcpy)-Operationen verwenden.Dann ist ein einzelner Vergleich erforderlich, der nicht zuerst die Zeichen mit strlen zählt;Stattdessen kennt es entweder die Größe im Voraus (wenn der Objektheader auch die Anzahl der Zeichen enthält, was wahrscheinlich ist), oder es läuft einfach bis zu einem 0-Byte.Das nennt man einmal vs.dreimal.Die tatsächliche Anzahl der zu vergleichenden Zeichen ist ungefähr gleich (vergessen Sie die zusätzlichen 0 Bytes).Damit bleiben uns zwei zusätzliche Aufrufe von strcmp (ein paar nS) gegenüber.Der Overhead, den ich oben beschrieben habe (einige US-Dollar).Wenn wir den GC-Rückgewinnungsaufwand addieren (0 Zuweisungen vs.4) Ich würde sagen, dass Ihre „optimierte“ Lösung leicht 100 bis 1000 Mal langsamer sein kann als die 3 strcmps!

Zusätzlicher Hinweis:
Theoretisch könnte der JITter es oder einen Teil davon optimieren und tatsächlich Code generieren, wie von Adam Bellaire vorgeschlagen, aber ich bezweifle, dass sich irgendein JIT-Entwickler darum kümmert, solchen Code zu optimieren.Übrigens sind die String-Routinen des Systems (auch bekannt als String-Operationen) normalerweise VIEL schneller als die manuelle Codierung, also beginnen Sie nicht, selbst einzelne Zeichen zu durchlaufen.

Answer 7

Ich würde die beiden Gruppen in zwei Arrays hinzufügen und dann über die Arrays schieben, um die einzelnen Zeichenfolgen in diesem Array zu vergleichen. Ein gutes Beispiel ist bereits in den Ansewers, die von Markus Lausberg gegeben sind.

Ich würde mich nicht über Leistungskosten besorgt. Schreiben Sie es einfach so lesbar möglich. Der Java -Compiler ist sehr gut in Leistungsoptimierungen.

Beispielmethode:

    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;
}

Und das Aufrufen der Methode ist natürlich einfach:

        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);

Answer 8

Ich würde den einfachen Weg verwenden

Dynamisch über alle Array -Elemente beider Arrays.

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

            return isEqual;