1. Converta a matriz para listar e depois usar o contém na lista para determinar se ela existe
public static boolean uselist (string [] arr, string containsValue) {return Arrays.asList (arr) .Contains (contenhaValue); }Deve -se notar que a lista convertida no método ASLIST. Entre eles, o comprimento da matriz não pode ser expandido. Isso é particularmente importante. A implementação contém é a seguinte:
@OverridePublic boolean contém (objeto o) {// CHAMADO INDEXOF Método para determinar qual posição é e determinar que é -1 retornar indexOf (o)! = -1;}@substituirpublic int indexof (objeto o) {// obtenha elemento e [] a = this.a; // JULGAR vazio se (o == null) {// julgamento de loop para (int i = 0; i <a.length; i ++) // se o elemento for nulo if (a [i] == null) // return i; } else {// se não estiver vazio para (int i = 0; i <A.Length; i ++) // julga se o elemento é igual a um [i] se (O.Equals (a [i])) // Retorno igual I return i; } // retornar -1 retornar -1;}2. Use definido para determinar se ele existe
public static boolean useSet (string [] arr, string containsValue) {return New HashSet <> (Arrays.asList (arr)). }Comparação de princípios de Array-> List-> Set usando o Set
Código -fonte: implementado pelo mapa de chamadas contém
ypublic boolean contém (objeto o) {return map.containskey (o); }3. Use loops para implementar, escreva um loop para julgar
public static boolean useloop (string [] arr, string contém valores) {// julgue se está vazio se (arr == null || arr.length == 0) {return false; } para (int i = 0; i <arr.length; i ++) {// all null if (conterValue! = null && conterevalue.equals (arr [i])) {return true; } else if (arr [i] == null) {return true; }} retornar false; }4. Use o método contém em org.apache.commons.lang3.arrayutils para implementá -lo
public static boolean useutils (string [] arr, string containsValue) {return Arrayutils.Contains (arr, contineValue); }Código fonte de implementação específica:
public estático booleano } public static int indexof (objeto final [], final ObjectTofind, int startIndex) {// juiz null if (array == null) {return index_not_found; } // Juiz Start Position if (startIndex <0) {startIndex = 0; } // julgue se o elemento de consulta é nulo se (objectTofind == null) {// null, use == para fazer um loop para julgar a posição por (int i = startIndex; i <array.length; i ++) {if (array [i] == null) {return i; }} // julgue se o elemento é uma instância de um elemento na matriz. Nesse caso, loop e use iguais para julgar} else if (Array.getClass (). GetComponentType (). IsInstance (objectTofind)) {for (int i = startIndex; i <Array.length; }}} // return não encontrado retorno index_not_found; }Use 1W ciclos para detectar eficiência
public static void recompilearr (string [] arr, string containsValue) {// usando a lista long start = system.nanotime (); para (int i = 0; i <10000; i ++) {uselist (arr, contineValue); } long end = System.nanotime (); System.out.println ("Usando Lista->"+(End-Start)/10000); // usando set start = system.nanotime (); for (int i = 0; i <10000; i ++) {usaTet (arr, contineValue); } end = system.nanotime (); System.out.println ("Usando set->"+(End-Start)/10000); // usando loop start = system.nanotime (); for (int i = 0; i <10000; i ++) {useloop (arr, contineValue); } 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, contê -se); } end = system.nanotime (); System.out.println ("Usando UTILS->"+(End-Start)/10000);}Os resultados são os seguintes:
Usando a lista-> 973
usando set-> 2676
usando loop-> 448
Usando UTILS-> 1364
A versão JDK usada é a versão JDK1.8.0_172, que pode ser inferida a partir do acima
Os quatro métodos acima têm alta eficiência -> baixo
LOOP> LISTA> UTILS> SET
Em comparação, pode -se observar que o uso do método de loop é o mais eficiente para julgar. Em seguida, vá para a lista, depois vá para os utilitários e depois vá para definir
Resumir:
Vamos analisar os motivos da lentidão:
O loop é o mais rápido, opera diretamente a matriz, sem dúvida
A lista é a segunda, porque precisa criar um java.util.array.arraylist, criar um objeto leva tempo, para que seja mais lento.
Terceiro, embora use loops semelhantes, Array.getClass (). getComponentType (). IsInstance (ObjectTofind), este código usa a chamada para o método nativo local. Sabemos que chamar o método nativo local será mais demorado do que chamar diretamente o método Java. Além disso, olhando para o código-fonte, você pode ver que getClass (), getComponentType () e isinstance são métodos nativos, que consomem muito tempo.
O conjunto é o pior, porque primeiro converte a matriz para listar e depois converte a lista para definir e, no set, ele usa o hashmap para implementá -lo. Como converte objetos muitas vezes, naturalmente, a eficiência definitivamente não é muito melhor.
Na verdade, eu pessoalmente prefiro usar Arrayutils para operação. Embora a proporção seja relativamente baixa, será muito pior?
O exposto acima é uma explicação detalhada das várias maneiras de comparar elementos de julgamento da matriz em Java em Java. Espero que seja útil para você. Se você tiver alguma dúvida, deixe -me uma mensagem e o editor responderá a você a tempo. Muito obrigado pelo seu apoio ao site wulin.com!