1. Konvertieren Sie das Array in die Auflistung und verwenden Sie dann die in der Liste enthaltenden, um festzustellen, ob es vorhanden ist
public static boolean uselist (String [] arr, String containsValue) {return arrays.aslist (arr) .contains (contentValue); }Es ist zu beachten, dass die konvertierte Liste in der Methode Arrays.aslist nicht java.util.arrayList ist, sondern java.util.arrays.arrayList. Unter ihnen kann die Länge des Arrays nicht erweitert werden. Dies ist besonders wichtig. Die enthält die Implementierung ist wie folgt:
@OverridePublic Boolean enthält (Objekt o) {// Aufruf -Index -Methode, um zu bestimmen, welche Position es ist, und festzustellen, dass es -1 -Rückgabeindex ist (o)! // Richter leer, wenn (o == null) {// Loop -Urteilsvermögen für (int i = 0; i <A.Length; i ++) // Wenn das Element null ist, wenn (a [i] == null) // Rückgabe I; } else {// wenn es nicht leer für (int i = 0; i <A.Length; i ++) // Beurteile, ob das Element gleich A [i] ist, wenn (o.equals (a [i]) // gleiche Rendite i zurücksenden i; } // Ansonsten return -1 return -1;}2. Verwenden Sie den Satz, um festzustellen, ob es existiert
public static boolean useset (String [] arr, String enthältValue) {return New Hashset <> (arrays.aslist (arr)). Enthält (contentValue); }Prinzip-Vergleich von Array-> List-> Set mit dem SET SET
Quellcode: Implementiert per Aufrufen von MAP enthält KEYSKEY, und HashMap wird durch Durchqueren des Schlüssels in der Hash -Tabelle implementiert
ypublic boolean enthält (Objekt o) {return map.containsKey (o); }3.. Verwenden Sie Schleifen, um zu implementieren, schreiben Sie eine Schleife an zu beurteilen
public static boolean useloop (String [] arr, String enthältValue) {// beurteilen, ob es leer ist, wenn (arr == null || arr.length == 0) {return false; } für (int i = 0; i <arr.length; i ++) {// alle null if (contentValue! = null && contentValue.equals (arr [i])) {return true; } else if (arr [i] == null) {return true; }} return false; }V.
public static boolean useutils (String [] arr, String containsValue) {return arrayutils.contains (arr, contentValue); }Spezifischer Implementierungsquellcode:
public static boolean enthält (endgültiges Objekt [] Array, endgültiges Objekt Objekttofind) {// Aufrufindex von Indexof aufrufen, um den Positionsrücklaufindex (Array, ObjectToFind)! = index_not_found zu bestimmen; } public static int indexof (endgültiges Objekt [] Array, endgültiges Objektobjekttofind, int startIndex) {// Richter null if (array == null) {return index_not_found; } // Richterstartposition if (startIndex <0) {startIndex = 0; } // Beurteilen Sie, ob das Abfrageelement null ist, wenn (ObjectTofind == null) {// null, use ==, um die Position für (int i = startIndex; i <array.length; i ++) {if (Array [i] == null) {return i; }} // beurteilen, ob das Element eine Instanz eines Elements im Array ist. Wenn ja, schleifen und verwenden Sie gleich, um zu richten} else if (array.getClass (). GetComponentType (). }}} // Rückgabe nicht gefunden return index_not_found; }Verwenden Sie 1W -Zyklen, um die Effizienz zu erkennen
public static void recompilearr (String [] arr, String enthält value) {// List Long start = system.nanotime (); für (int i = 0; i <10000; i ++) {uselist (arr, contentValue); } Long End = System.nanotime (); System.out.println ("List->"+(Endstart)/10000); // mit set start = system.nanotime () verwenden; für (int i = 0; i <10000; i ++) {Nutzung (arr, contentValue); } end = system.nanotime (); System.out.println ("mit set->"+(endstart)/10000); // mit Loop start = system.nanotime () verwenden; für (int i = 0; i <10000; i ++) {useloop (arr, contentValue); } end = system.nanotime (); System.out.println ("LOOP->"+(Endstart)/10000); // Verwenden von utils start = system.nanotime (); für (int i = 0; i <10000; i ++) {useutils (arr, contentValue); } end = system.nanotime (); System.out.println ("Verwenden von Utils->"+(Endstart)/10000);}Die Ergebnisse sind wie folgt:
Verwenden von List-> 973
Verwenden von SET-> 2676
mit Loop-> 448
Verwenden von Utils-> 1364
Die verwendete JDK -Version ist die JDK1.8.0_172 -Version, die aus dem obigen abgeleitet werden kann
Die obigen vier Methoden haben eine hohe Effizienz -> niedrig
Schleife> Liste> Utils> Set
Im Vergleich dazu ist ersichtlich, dass die Verwendung der Schleifenmethode am effizientesten ist. Gehen Sie dann zur Liste, gehen Sie dann zu Utils und gehen Sie dann zum Set
Zusammenfassen:
Lassen Sie uns die Gründe für die Langsamkeit analysieren:
Schleife ist das schnellste, ohne Zweifel das Array direkt betreiben
Die Liste ist der zweite, da sie eine java.util.array.ArrayList erstellen muss, sodass ein Objekt Zeit braucht, sodass es langsamer ist.
Util drittens, obwohl es ähnliche Schleifen verwendet, Array.getClass (). GetComponentType (). Wir wissen, dass das Aufrufen der lokalen nativen Methode zeitaufwändiger sein wird, als die Java-Methode direkt aufzurufen. Wenn Sie sich den Quellcode ansehen, können Sie sehen, dass GetClass (), GetComponentType () und Issinstance beide native Methoden sind, die sehr zeitaufwändig sind.
Das Set ist das Schlimmste, da es das Array zuerst in die Auflistung konvertiert und dann die Liste in die Set umwandelt und in der SET HashMap verwendet, um es zu implementieren. Weil es um ein Vielfaches Objekte umwandelt, ist die Effizienz natürlich nicht viel besser.
Eigentlich bevorzuge ich es, Arrayutils für den Betrieb zu verwenden. Obwohl das Verhältnis relativ niedrig ist, wird es dann viel schlimmer?
Das obige ist eine detaillierte Erklärung der verschiedenen Möglichkeiten, um Array -Urteilselemente in Java in Java zu vergleichen. Ich hoffe, es wird Ihnen hilfreich sein. Wenn Sie Fragen haben, hinterlassen Sie mir bitte eine Nachricht und der Editor wird Ihnen rechtzeitig antworten. Vielen Dank für Ihre Unterstützung auf der Wulin.com -Website!