Red de conocimiento informático - Problemas con los teléfonos móviles - ¿Las descripciones en una prueba de Scala se ejecutan secuencialmente?

¿Las descripciones en una prueba de Scala se ejecutan secuencialmente?

useList

1

2

3

úblico

estático

booleano

useList(String[] arr, String targetValue) {

return

Arrays.asList(arr).contains(targetValue);

}

Usar conjunto

1

2

3

4

público

estático

booleano

useSet(String[] arr, String targetValue) {

Establecer

set = new

HashSet

Retorno

set.contains(targetValue); p>

}

Usar criterio de bucle

1

2

3

4

5

6

7

Público

Estático

Booleano

useLoop(String[] arr, String targetValue) {

for(String

s: arr ){

if(s.equals (targetValue ))

Devuelve

verdadero;

}

Devuelve

falso;

}

Utilice Arrays.binarySearch()

¡¡¡El método Arrays.binarySearch() sólo se puede utilizar para matrices ordenadas!!! Si la matriz no está ordenada, los resultados serán extraños.

El método para saber si una matriz ordenada contiene un valor es el siguiente:

1

2

3

4

5

6

7

Público

estático

booleano

p>

useArraysBinarySearch(String[] arr, String targetValue) {

int

a = Arrays.binarySearch(arr, targetValue)

El método de búsqueda binaria (Arrays.binarySearch) solo se puede utilizar en matrices ordenadas. binarioSearch(arr, targetValue);

if(a

> ; 0)

return

true;

else

return

false;

}

Complejidad del tiempo

El siguiente código proporciona el tiempo aproximado costos de varios métodos. La idea básica es encontrar un valor a partir de una matriz de tamaño 5, 1k y 10k. Los resultados obtenidos por este método pueden no ser precisos, pero es el método más simple y claro.

1

2

3

4

5

6 p>

7

8

9

10

11

12

13

14

15 i++){

arr[i]

= String.valueOf(s. nextInt( ));

}

Resultado:

1

2

3

4

useList:

112

useSet:

2055

useLoop:

99

useArrayBinary:

12

Utilice una matriz de longitud 10k

1

2

3

4

5

6

Cadena[]

arr = nuevo

Cadena[10000];

Aleatorio

s = nuevo

Aleatorio(); >for (int

i=0;

i< 10000;

i++){

arr[i]

= String.valueOf(s.nextInt());

}

Resultado:

1

2

3

4

useList:

1590

useSet:

23819

useLoop:

1526

useArrayBinary:

12

Resumen

Obviamente, utilizar Un enfoque de bucle simple es más eficiente que usar cualquier colección. Muchos desarrolladores utilizan el primer método por conveniencia, pero también es relativamente ineficiente. Esto se debe a que al insertar una matriz en un tipo de colección, primero se itera sobre los elementos de la matriz antes de realizar otras operaciones con la clase de colección.

Si utiliza el método Arrays.binarySearch(), la matriz debe estar ordenada. Dado que la matriz anterior no está ordenada, este método no está disponible.

De hecho, si necesita la ayuda de una matriz o clase de colección para verificar de manera eficiente si una matriz contiene un valor específico, la complejidad temporal de una lista o árbol ordenado es O(log(n) ), mientras que un hash La complejidad temporal de la colección es O (1).

(Fin del texto original en inglés, nota del traductor aquí)

Uso de ArrayUtils

Además de los métodos anteriores, la biblioteca de clases Apache Commons también proporciona una Clase ArrayUtils, puede utilizar su método contiene para determinar la relación entre matrices y valores.

1

2

3

4

importar

org.apache .commons.lang3.ArrayUtils;

público

estático

booleano

useArrayUtils(String[] arr, String targetValue) {

return

ArrayUtils.includes(arr,targetValue);

}

Hicimos lo mismo usando las matrices de las longitudes anteriores Después de las pruebas, se descubrió que la eficiencia de este método se encuentra entre el uso de conjuntos y el uso de juicios de bucle (en algunos casos, los resultados son incluso mejores que el uso de juicios de bucle).

1

2

3

4

5

6 p>

7

8

9

10

11

useList:

323

useSet:

3028

useLoop:

141

useArrayBinary:

p>

12

useArrayUtils:

181

-------

useList:

3703

useSet:

35183

useLoop:

3218

useArrayBinary :

14

useArrayUtils:

3125

De hecho, si observa el código fuente de ArrayUtils.contains, verá Vea que en realidad usa una prueba de bucle para determinar si un elemento está contenido en una matriz.

Parte del código es el siguiente:

1

2

3

4

5

6

7

8

9

10

11

12

13