1. Convierta la matriz en la lista y luego use la lista contiene en la lista para determinar si existe
Public static boolean uselist (string [] arr, string contieneSvalue) {return arrays.aslist (arr) .contains (contenerValue); }Cabe señalar que la lista convertida en el método matriz.aslist no es java.util.arraylist sino java.util.arrays.arraylist. Entre ellos, la longitud de la matriz no se puede ampliar. Esto es particularmente importante. La implementación contiene es la siguiente:
@OverridePublic boolean contiene (objeto o) {// índice de llamada de llamadas para determinar qué posición es, y determine que es -1 de return indexOf (o)! = -1;}@overridePublic int indexOf (objeto o) {// get element e [] a = this.a; // juzga vacío if (o == null) {// bucle juicio para (int i = 0; i <a.length; i ++) // Si el elemento es nulo if (a [i] == null) // return return i; } else {// Si no está vacío para (int i = 0; i <a.length; i ++) // juzga si el elemento es igual a un [i] if (o.equals (a [i])) // Devuelto igual que devuelve i; } // De lo contrario, return -1 return -1;}2. Use el conjunto para determinar si existe
Public static boolean useet (string [] arr, string contieneSvalue) {return new Hashset <> (arrays.aslist (arr)). contiene (contenervalue); }Comparación principal de la matriz-> list-> set usando set
Código fuente: Implementado por Calling Map contiene Key, y HashMap se implementa atravesando la clave en la tabla hash
ypublic boolean contiene (objeto o) {return map.containskey (o); }3. Use bucles para implementar, escriba un bucle para juzgar
public static boolean useLoop (string [] arr, string contieneValue) {// juzga si está vacío if (arr == null || arr.length == 0) {return false; } for (int i = 0; i <arr.length; i ++) {// Todo nulo if (contreiteValue! = null && contvenvalue.equals (arr [i])) {return true; } else if (arr [i] == null) {return true; }} return false; }4. Use el método contenido en org.apache.commons.lang3.arrayutils para implementarlo
Public static boolean useUtils (string [] arr, string contieneSvalue) {return arrayUtils.contains (arr, contre contieValue); }Código fuente de implementación específico:
public static boolean contiene (matriz de objeto final [], objeto final de objeto tótido) {// índice de llamada de índice de índice para determinar el índice de retorno de posición (array, objectToFind)! = index_not_found; } public static int indexOf (objeto final [] Array, Object Final ObjectToFind, int StartIndex) {// juez null if (array == null) {return index_not_found; } // juzga la posición de inicio if (startIndex <0) {startIndex = 0; } // juzga si el elemento de consulta es nulo if (objectToFind == null) {// null, use == para hacer bucle para juzgar la posición (int i = startIndex; i <array.length; i ++) {if (array [i] == null) {return i; }} // juzga si el elemento es una instancia de un elemento en la matriz. Si es así, bucle y use iguales para juzgar} else if (array.getclass (). GetComponentType (). IsInstance (ObjectToFind)) {for (int i = startIndex; i <array.length; i ++) {if (objectToFind.equals (array [i])) {return i; }}} // return no encontrado return index_not_found; }Use ciclos de 1W para detectar la eficiencia
public static void recompilearr (string [] arr, string contensValue) {// usando list long start = system.nanotime (); para (int i = 0; i <10000; i ++) {useList (arr, contre contieValue); } Long End = System.nanotime (); System.out.println ("Usando List->"+(End-start)/10000); // usando set start = system.nanotime (); para (int i = 0; i <10000; i ++) {useet (arr, contre contreValue); } end = system.nanotime (); System.out.println ("Usando set->"+(end-start)/10000); // usando bucle start = system.nanotime (); para (int i = 0; i <10000; i ++) {useeloop (arr, contre contrealue); } end = system.nanotime (); System.out.println ("Usando loop->"+(end-start)/10000); // usando utils start = system.nanotime (); para (int i = 0; i <10000; i ++) {useUtils (arr, contre contrealue); } end = system.nanotime (); System.out.println ("Usando Utils->"+(End-start)/10000);}Los resultados son los siguientes:
Usando list-> 973
Usando set-> 2676
Usando bucle-> 448
Usando Utils-> 1364
La versión JDK utilizada es la versión JDK1.8.0_172, que se puede inferir de lo anterior
Los cuatro métodos anteriores tienen alta eficiencia -> baja
bucle> list> utils> set
En comparación, se puede ver que usar el método de bucle es el más eficiente para juzgar. Luego vaya a la lista, luego vaya a UTILS y luego vaya a SET
Resumir:
Analicemos las razones de la lentitud:
El bucle es la matriz más rápida y operativa, sin duda
La lista es la segunda, porque necesita crear un java.util.array.arrayList, crear un objeto lleva tiempo, por lo que será más lento.
Util Third, aunque utiliza bucles similares, Array.getClass (). GetComponentType (). ISInStance (ObjectToFind), este código usa la llamada al método nativo local. Sabemos que llamar al método nativo local llevará más tiempo que llamar directamente al método Java. Además, al observar el código fuente, puede ver que GetClass (), GetComponentType () e ISInstance son métodos nativos, que requieren mucho tiempo.
El conjunto es el peor, porque primero convierte la matriz en la lista, y luego convierte la lista para establecer, y en el conjunto, usa HashMap para implementarlo. Debido a que convierte objetos muchas veces, naturalmente, la eficiencia definitivamente no es mucho mejor.
En realidad, personalmente prefiero usar ArrayUtils para la operación. Aunque la relación es relativamente baja, ¿será mucho peor?
Lo anterior es una explicación detallada de las diversas formas de comparar elementos de juicio de matriz en Java en Java. Espero que te sea útil. Si tiene alguna pregunta, déjame un mensaje y el editor le responderá a tiempo. ¡Muchas gracias por su apoyo al sitio web de Wulin.com!