que - serializacion en java netbeans
¿Qué implementación de la lista<Objeto> será la más rápida para la escritura de un solo paso, leer y luego destruir? (8)
La iteración a través de una lista vinculada es O (1) por elemento.
El tiempo de ejecución de Big O para cada opción es el mismo. Probablemente ArrayList sea más rápido debido a una mejor localidad de memoria, pero tendría que medirlo para estar seguro. Elija lo que haga que el código sea más claro.
¿Cuál es la implementación más rápida de la lista (en java) en un escenario donde la lista se creará un elemento a la vez y luego, en un punto posterior, se leerá un elemento a la vez? Las lecturas se realizarán con un iterador y luego la lista se destruirá.
Sé que la notación de Big O para get es O (1) y add es O (1) para una ArrayList, mientras que LinkedList es O (n) para get y O (1) para add. ¿El iterador se comporta con la misma notación de Big O?
Sugiero hacer una evaluación comparativa. Una cosa es leer la API, pero hasta que no la pruebes, sería académica.
Debería ser fácil de probar, solo asegúrate de hacer operaciones significativas, o el punto de conexión te superará y optimizará todo para NO-OP :)
Tenga en cuenta que iterar a través de una instancia de LinkedList puede ser O (n ^ 2) si se hace ingenuamente. Específicamente:
List<Object> list = new LinkedList<Object>();
for (int i = 0; i < list.size(); i++) {
list.get(i);
}
Esto es absolutamente horrible en términos de eficiencia debido al hecho de que la lista debe atravesarse hasta i dos veces para cada iteración. Si usa LinkedList , asegúrese de usar un Iterator o Java 5 mejorado for -loop:
for (Object o : list) {
// ...
}
El código anterior es O (n), ya que la lista se atraviesa de manera estable en el lugar.
Para evitar todas las molestias anteriores, simplemente use ArrayList . No siempre es la mejor opción (especialmente para la eficiencia del espacio), pero generalmente es una apuesta segura.
Primeros pensamientos:
- Refactorice su código para que no necesite la lista.
- Simplifique los datos a un tipo de datos escalar, luego use: int []
- O simplemente use una matriz de cualquier objeto que tenga: Objeto [] - John Gardner
- Inicialice la lista al tamaño completo: nueva ArrayList (123);
Por supuesto, como todos los demás mencionan, realice pruebas de rendimiento, demuestre que su nueva solución es una mejora.
Es casi seguro que quiere una ArrayList . Tanto la adición como la lectura son "tiempo constante amortizado" (es decir, O (1)) como se especifica en la documentación (tenga en cuenta que esto es cierto incluso si la lista tiene que aumentar su tamaño; está diseñado de esa manera, consulte http: //java.sun .com / j2se / 1.5.0 / docs / api / java / util / ArrayList.html ). Si sabe aproximadamente la cantidad de objetos que almacenará, incluso se eliminará el aumento de tamaño de ArrayList.
Agregar al final de una lista vinculada es O (1), pero el multiplicador constante es más grande que ArrayList (ya que generalmente se está creando un objeto nodo cada vez). La lectura es prácticamente idéntica a ArrayList si está utilizando un iterador.
Es una buena regla usar siempre la estructura más simple que pueda, a menos que haya una buena razón para no hacerlo. Aquí no hay tal razón.
La cita exacta de la documentación de ArrayList es: "La operación de adición se ejecuta en tiempo constante amortizado, es decir, agregar n elementos requiere O (n) tiempo. Todas las demás operaciones se ejecutan en tiempo lineal (aproximadamente hablando). El factor constante es bajo en comparación con el de la implementación LinkedList ".
Depende en gran medida de si conoce el tamaño máximo de cada lista por adelantado.
Si lo hace, use ArrayList ; sin duda será más rápido.
De lo contrario, es probable que tengas que crear un perfil. Si bien el acceso a ArrayList es O (1), crearlo no es tan simple, debido al cambio de tamaño dinámico.
Otro punto a considerar es que la compensación del espacio-tiempo no es clara. Cada objeto Java tiene bastante sobrecarga. Si bien un ArrayList puede desperdiciar algo de espacio en las ranuras sobrantes, cada ranura tiene solo 4 bytes (o 8 en una JVM de 64 bits). Cada elemento de una LinkedList es probablemente de unos 50 bytes (quizás 100 en una JVM de 64 bits). Por lo tanto, debe tener bastantes máquinas tragamonedas desperdiciadas en una ArrayList antes de que LinkedList gane su supuesta ventaja de espacio. La localidad de referencia también es un factor, y ArrayList es preferible allí también.
En la práctica, casi siempre uso ArrayList .
De hecho, he empezado a pensar que se debe evitar el uso de estructuras de datos con un comportamiento no determinista, como ArrayList o HashMap, por lo que yo diría que solo use ArrayList si puede enlazar su tamaño; cualquier lista ilimitada usa LinkedList. Sin embargo, eso se debe a que, principalmente, codigo sistemas con requisitos de tiempo casi real.
El problema principal es que cualquier asignación de memoria (que podría ocurrir al azar con cualquier operación de adición) también podría causar una recolección de basura, y cualquier recolección de basura puede causar que pierda un objetivo. Cuanto mayor sea la asignación, más probabilidades habrá de que esto ocurra, y esto también se agravará si está utilizando el recopilador de CMS. CMS no es compactante, por lo que encontrar espacio para un nuevo nodo de lista enlazado generalmente será más fácil que encontrar espacio para una nueva matriz de 10.000 elementos.
Cuanto más riguroso sea su enfoque de codificación, más cerca podrá llegar en tiempo real con una JVM estándar. Pero elegir solo estructuras de datos con un comportamiento determinista es uno de los primeros pasos que debería tomar.