Compare varios métodos para determinar los elementos contenidos en una matriz en Java
paquete test.contain.lishaojie;
importar java.util.Arrays;
importar java.util.HashSet;
importar java.util.Set;
clase pública TestContain {
/**
* @param.Set;
clase pública TestContain {
/**
* @param args
*/
public static void main(String[] args ) {
//TODO genera automáticamente un código auxiliar de método
String[] arr = new String[] { "DD", "CC", "DD", "FF", " KK"};
String target = "A";
int times = 1000; //count
//Convertir a modo lista
long startTime = System.currentTimeMillis();
for (int i = 0; i lt; times; i) {
ByList(arr, target); p>
}
long startTime = System.currentTimeMillis();
for (int i = 0; i lt; times; i ) {
BySet(arr, target);
}
endTime = System.currentTimeMillis();
duración = endTime - startTime;
p>System.out.println("método establecido: " duración / 1000000);
Método de bucle directo
startTime = System.currentTimeMillis();
for (int i = 0; i lt; times; i) {
ByForLoop(arr, target
}
duración = endTime - startTime;
System.out.Printn("Modo de bucle: " duración / 1000000);
For ( int i = 0; i lt; times; i )currentTimeMillis();
duración = endTime - startTime;
System.out.println("Búsqueda binaria: " duración / 1000000 );
}
público estático booleano B
yList(String[] arr, String targetValue) {
return Arrays.contains(targetValue);
}
público estático booleano BySet(String[] arr , String targetValue) {
Setlt; Stringgt; set = new HashSetlt; (Arrays.asList(arr)); >
}
público estático booleano ByForLoop( String[] arr, String targetValue) {
for(String s: arr){
if( s.equals(targetValue))
devuelve verdadero;
}
devuelve falso;
}
público estático booleano ByArraysBinarySearch(String[] arr, String targetValue) {
int a = Arrays.binarySearch(arr, targetValue);
if(a gt; 0)
devuelve verdadero;
else
devuelve falso;
}
}
Resultados en ejecución De la siguiente manera:
Método de lista: 5
Método de conjunto: 22
Método de bucle: 2
Búsqueda binaria: 3
Después de muchas pruebas de datos, el método de bucle es el más eficiente, seguido de la búsqueda binaria y finalmente la lista. El motivo del conjunto es que la matriz se convierte en un tipo de Colección. debe atravesarse una vez y luego usar la clase para realizar otras operaciones. Pero el método de lista es obviamente mucho más rápido que el método de conjunto. ¿Por qué? Mire el código directamente: Primero
@SafeVarargs
@SuppressWarnings("varargs")
public static Tgt; .. .a) {
return new ArrayListlt;gt;(a);
}
Lo que se devuelve es un ArrayList, por lo que el método set debe realice otra operación, convierta ArrayList en una colección,
public HashSet( Collectionlt;? extends Egt; c) {
map = new HashMaplt (Math.max((int; ) (c .size()/.75f) 1, 16));
addAll(c);
}
Uno de los métodos de addAll :
Este es el método addAll.
extiende Egt; c) {
booleano modificado = false;
for (E e: c)
if (add(e))
modificado = true;
retorno modificado
}
Otra opción circular y por tanto menos eficiente, bingo