1. Methode zur Überprüfung, ob das Array einen bestimmten Wert enthält
Verwenden Sie die Liste
public static boolean uselist (String [] arr, String targetValue) {return arrays.aslist (arr) .Contains (targetValue);}Verwenden von Set
public static boolean useset (String [] arr, String targetValue) {set <string> set = new Hashset <string> (Arrays.aslist (arr)); return set.contains (targetValue);}Verwenden Sie das Schleifenurteil
public static boolean useloop (String [] arr, String targetValue) {für (String S: arr) {if (s.equals (targetValue)) return true; } return false;}Verwenden Sie Arrays.BinarySearch ()
Arrays.binarySearch() -Methode kann nur für bestellte Arrays verwendet werden! ! ! Wenn das Array nicht angeordnet ist, wird das Ergebnis sehr seltsam sein.
Die Verwendung, ob ein geordnetes Array einen bestimmten Wert enthält, ist wie folgt:
public static boolean usearraysBinarySearch (String [] arr, String targetValue) {int a = arrays.binarysearch (arr, targetValue); if (a> 0) true zurück; sonst return false;}Zeitkomplexität
Der folgende Code kann die Zeitkosten verschiedener Methoden grob zeichnen. Die Grundidee besteht darin, einen bestimmten Wert aus einem Array zu finden, und die Größen des Arrays betragen 5, 1k bzw. 10K. Die nach dieser Methode erzielten Ergebnisse sind möglicherweise nicht genau, aber die einfachste und klarste Art.
public static void main (String [] args) {String [] arr = new String [] {"CD", "BC", "EF", "DE", "AB"}; // LIST LONG STARTIME = SYSTEM.NANOTIME () verwenden; für (int i = 0; i <100000; i ++) {uselist (arr, "a"); } Long endzeit = System.nanotime (); lange Dauer = Endzeit - Starttime; System.out.println ("USEList:" + Dauer / 1000000); // set startTime = system.nanotime () verwenden; für (int i = 0; i <100000; i ++) {useet (arr, "a"); } endTime = System.nanotime (); Dauer = Endzeit - Starttime; System.out.println ("Nutzung:" + Dauer / 1000000); // Loop StartTime = System.Nanotime () verwenden; für (int i = 0; i <100000; i ++) {useloop (arr, "a"); } endTime = System.nanotime (); Dauer = Endzeit - Starttime; System.out.println ("useloop:" + duration / 1000000); // arrays.binarysearch () startTime = System.nanotime () verwenden; für (int i = 0; i <100000; i ++) {UsearraysBinarySearch (arr, "a"); } endTime = System.nanotime (); Dauer = Endzeit - Starttime; System.out.println ("UsearrayBinary:" + Dauer / 1000000);}Auslaufergebnisse:
USELIST: 13USSET: 72USeloop: 5USearraysBinarySearch: 9
Verwenden Sie eine Reihe von Länge 1k
String [] arr = new String [1000]; Random s = new random (); für (int i = 0; i <1000; i ++) {arr [i] = String.ValueOf (s.NextInt ());}Ergebnis:
USELIST: 112USESET: 2055USELOOP: 99USARAYBINY: 12
Verwenden Sie eine Länge von 10 k
String [] arr = new String [10000]; Random s = new random (); für (int i = 0; i <10000; i ++) {arr [i] = string.ValueOf (s.NextInt ());}Ergebnis:
USELIST: 1590USSETSET: 23819USeloop: 1526uSearrayBinary: 12
Zusammenfassung
Offensichtlich ist die Verwendung einer einfachen Schleifenmethode effizienter als die Verwendung einer Sammlung. Viele Entwickler verwenden die erste Methode aus Gründen der Bequemlichkeit, aber ihre Effizienz ist auch relativ gering. Da Sie ein Array in den Sammelart drücken, müssen Sie zuerst die Array -Elemente durchqueren und dann die Sammelklasse verwenden, um andere Operationen auszuführen.
Wenn Sie Arrays.binarySearch() verwenden, muss das Array sortiert werden. Da das obige Array nicht sortiert ist, ist diese Methode nicht verfügbar.
Wenn Sie Arrays oder Sammelklassen verwenden müssen, um effizient zu überprüfen, ob das Array einen bestimmten Wert enthält, kann eine sortierte Liste oder ein Baum eine zeitliche Komplexität von O (log (n)) erreichen, und Hashset kann O (1) erreichen.
Verwenden von Arrayutils
Zusätzlich zu den oben genannten Bereichen der Apache Commons -Klassenbibliothek bietet auch eine Arrayutils -Klasse, die ihre Methode enthält, um die Beziehung zwischen Arrays und Werten zu beurteilen.
import org.apache.commons.lang3.arrayutils; public static boolean usearrayutils (String [] arr, String targetValue) {return arrayutils.contains (arr, targetValue);}Der gleiche Test wurde unter Verwendung von Arrays der oben genannten Längen durchgeführt, und das Ergebnis war, dass die Effizienz dieser Methode zwischen den Verwendung von Sets und der Verwendung von Schleifenurteilen war (manchmal war das Ergebnis noch idealer als die Verwendung von Schleifen).
USELIST: 323USESET: 3028useloop: 141uSearrayBinary: 12uSearrayutils: 181 ---------- USELIST: 3703USSET: 35183USELOOP: 3218USEARRAYBINY: 14USEARRAYUTILS: 3125
Wenn Sie sich den Quellcode von Arrayutils.Contains ansehen, können Sie feststellen, dass dies tatsächlich eine Möglichkeit ist, zu beurteilen, ob ein Element in einem Array enthalten ist.
Einige der Codes sind wie folgt:
if (array == null) {return -1; } else {if (startIndex <0) {startIndex = 0; } int i; if (ObjectTofind == null) {für (i = startIndex; i <array.length; ++ i) {if (Array [i] == null) {return i; }}} else if (array.getClass (). getComponentType (). isInstance (ObjectTofind)) {für (i = startIndex; i <array.length; ++ i) {if (ObjectTofind.equals (array [i]) {return i; }}} return -1; }Im Vergleich dazu lieber ich die Arrayutils -Werkzeugklasse lieber, um einige Operationen im Zusammenhang mit dem kombinierten Zahlen -Vorfahren auszuführen. Immerhin kann er mich weniger Code weniger schreiben lassen (da es beim Schreiben von Code für mich unweigerlich Fehler gibt. Schließlich wurde die von Apache bereitgestellte Open -Source -Toolbibliothek von unzähligen Entwicklern getestet) und die Effizienz ist nicht viel niedriger.
Zusammenfassen
OK, das obige dreht sich alles um diesen Artikel. Ich hoffe, der Inhalt dieses Artikels wird für alle helfen, Java zu lernen oder zu verwenden. Wenn Sie Fragen haben, können Sie eine Nachricht zur Kommunikation überlassen.