1. Método para verificar si la matriz contiene un cierto valor
Lista de uso
Public static boolean uselist (string [] arr, string TargetValue) {return arrays.aslist (arr) .contains (targetValue);}Usando set
public static boolean useet (string [] arr, string TargetValue) {set <string> set = new Hashset <String> (arrays.aslist (arr)); return set.contains (TargetValue);}Usar el juicio de bucle
public static boolean useLoop (string [] arr, string TargetValue) {for (String s: arr) {if (s.equals (targetValue)) return true; } return false;}Use Arrays.BinarySearch ()
Arrays.binarySearch() solo se puede usar para matrices ordenadas! ! ! Si la matriz está desordenada, el resultado será muy extraño.
El uso de encontrar si una matriz ordenada contiene un cierto valor es el siguiente:
Public static boolean useRarraySbinarySearch (string [] arr, string targetValue) {int a = arrays.binarySearch (arr, targetValue); if (a> 0) devolver verdadero; else devuelve falso;}Complejidad del tiempo
El siguiente código puede generar aproximadamente el costo de tiempo de varios métodos. La idea básica es encontrar un cierto valor de una matriz, y los tamaños de la matriz son 5, 1K y 10K respectivamente. Los resultados obtenidos por este método pueden no ser precisos, pero son la forma más simple y clara.
public static void main (string [] args) {string [] arr = new String [] {"cd", "bc", "ef", "de", "ab"}; // usa la lista de inicio larga = system.nanotime (); para (int i = 0; i <100000; i ++) {useList (arr, "a"); } largo endtime = system.nanotime (); Larga duración = tiempo endgente - starttime; System.out.println ("uselist:" + duración / 1000000); // use set starttime = system.nanotime (); para (int i = 0; i <100000; i ++) {useet (arr, "a"); } endtime = system.nanotime (); Duración = EndTime - Starttime; System.out.println ("Usset:" + Duración / 1000000); // use bucle starttime = system.nanotime (); para (int i = 0; i <100000; i ++) {useloop (arr, "a"); } endtime = system.nanotime (); Duración = EndTime - Starttime; System.out.println ("Useloop:" + Duración / 1000000); // use arrays.binarySearch () starttime = system.nanotime (); para (int i = 0; i <100000; i ++) {useRearRaysbinarySearch (arr, "a"); } endtime = system.nanotime (); Duración = EndTime - Starttime; System.out.println ("UsearRayBinary:" + Duración / 1000000);}Resultados de ejecución:
USELIST: 13USESET: 72useloop: 5usEarraysbinarySearch: 9
Use una variedad de longitud 1K
String [] arr = new String [1000]; Random S = New Random (); for (int i = 0; i <1000; i ++) {arr [i] = string.ValueOf (s.nextInt ());}resultado:
USELIST: 112 USET: 2055USELOOP: 99USEARRAYBINARIO: 12
Use una matriz de longitud 10k
String [] arr = new String [10000]; Random S = New Random (); para (int i = 0; i <10000; i ++) {arr [i] = string.ValueOf (s.nextInt ());}resultado:
USELIST: 1590 USET: 23819USELEOP: 1526UsearRayBinary: 12
resumen
Obviamente, usar un método de bucle simple es más eficiente que usar cualquier colección. Muchos desarrolladores usan el primer método para la conveniencia, pero su eficiencia también es relativamente baja. Debido a que presiona una matriz en el tipo de colección, primero debe atravesar los elementos de la matriz y luego usar la clase de colección para hacer otras operaciones.
Si usa Arrays.binarySearch() , la matriz debe clasificarse. Dado que la matriz anterior no está ordenada, este método no está disponible.
De hecho, si necesita usar matrices o clases de recolección para verificar de manera eficiente si la matriz contiene un valor específico, una lista o árbol ordenado puede lograr una complejidad de tiempo de o (log (n)), y hashset puede lograr O (1).
Usando Arrayutils
Además de lo anterior, la Biblioteca de la clase Apache Commons también proporciona una clase de ArrayUtils, que puede usar su método Contiene para juzgar la relación entre matrices y valores.
importar org.apache.commons.lang3.arrayutils; public static boolean usearrayutils (string [] arr, string TargetValue) {return ArrayUtils.contains (arr, targetValue);}La misma prueba se realizó utilizando matrices de las longitudes anteriores, y el resultado fue que la eficiencia de este método era entre usar conjuntos y usar juicios de bucle (a veces el resultado fue aún más ideal que usar bucles).
USELISTA: 323USESET: 3028USELOOP: 141UsearRayBinary: 12UsearRayUtils: 181 ---------- USELISTA: 3703USESET: 35183USELELOOP: 3218 UsearRayBinary: 14usearRayUtils: 3125
De hecho, si observa el código fuente de ArrayUtil.contains, puede encontrar que en realidad es una forma de juzgar si un elemento está incluido en una matriz.
Algunos de los códigos son los siguientes:
if (array == null) {return -1; } else {if (startIndex <0) {startIndex = 0; } int i; if (objectToFind == null) {for (i = startIndex; i <array.length; ++ i) {if (array [i] == null) {return i; }}} else if (array.getclass (). getComponentType (). IsInstance (objectToFind)) {for (i = startIndex; i <array.length; ++ i) {if (objectTOfind.equals (array [i]) {return i; }}} return -1; }Entonces, en comparación, prefiero usar la clase de herramientas ArrayUtils para realizar algunas operaciones relacionadas con el ancestro de número combinado. Después de todo, puede permitirme escribir mucho código menos (porque inevitablemente hay errores al escribir código por mí mismo. Después de todo, la biblioteca de herramientas de código abierto proporcionada por Apache ha sido probada por innumerables desarrolladores), y la eficiencia no es mucho menor.
Resumir
Ok, lo anterior se trata de este artículo. Espero que el contenido de este artículo sea de ayuda para que todos aprendan o usen Java. Si tiene alguna pregunta, puede dejar un mensaje para comunicarse.