Reducción de una lista de arreglos a un nuevo tamaño

Question

¿Realmente necesito implementarlo yo mismo?

private void shrinkListTo(ArrayList<Result> list, int newSize) { 
    for (int i = list.size() - 1; i >= newSize; --i) 
    list.remove(i); 
} 

Answer 1

Crear una sublist con la gama de elementos que desea eliminar y luego llamar clear en la lista devuelta.

list.subList(23, 45).clear() 

Este enfoque es mencionado como un idioma en la documentación tanto para List y ArrayList.

---

¡Aquí tenemos un ejemplo de código totalmente probado!

// limit yourHappyList to ten items 
int k = yourHappyList.size(); 
if (k > 10) 
    yourHappyList.subList(10, k).clear(); 
    // sic k, not k-1 

Answer 2

uso ArrayList#removeRange() método:

protegido removeRange void (int fromIndex, int toIndex)

elimina de esta lista todos los elementos cuyo índice es entre fromIndex, inclusive, y toIndex , exclusivo. Cambia los elementos sucesivos a la izquierda (reduce su índice). Esta llamada acorta la lista por elementos (toIndex - fromIndex). (Si toIndex == fromIndex, esta operación no tiene efecto.)

a continuación, utilizar ArrayList#trimToSize() método:

Ribetes la capacidad de esta instancia ArrayList ser tamaño actual de la lista. Una aplicación puede usar esta operación para minimizar el almacenamiento de una instancia de ArrayList.

Answer 3

Hay otra consideración. Es posible que desee evitar el uso de un ArrayList en la firma de su método y trabajar en la interfaz List, ya que lo vincula con la implementación ArrayList, dificultando los cambios si encuentra que, por ejemplo, un LinkedList es más adecuado a sus necesidades. Evitar este acoplamiento ajustado tiene un costo.

Un enfoque alternativo podría tener este aspecto:

private void shrinkListTo(List<Result> list, int newSize) { 
    list.retainAll(list.subList(0, newSize); 
} 

Por desgracia, el método List.retainAll() es opcional para las subclases para poner en práctica, por lo que necesitaría un catchUnsupportedOperationException, y luego hacer otra cosa.

private void shrinkListTo(List<Result> list, int newSize) { 
    try { 
    list.retainAll(list.subList(0, newSize); 
    } catch (UnspportedOperationException e) { 
    //perhaps log that your using your catch block's version. 
    for (int i = list.size() - 1; i >= newSize; --i) 
     list.remove(i); 
    } 
    } 
} 

Eso no es tan directo como su original. Si no está vinculado a la instancia de la Lista que está transfiriendo, puede devolver fácilmente una nueva instancia llamando al subList(int start, int end), e incluso no necesitaría hacer un método. Esto también sería una implementación más rápida, ya que (en Java 6), obtendría una instancia de AbstractList.SubList que contiene su lista, un desplazamiento en ella y un tamaño. No habría necesidad de iterar.

Si usted está interesado en los argumentos para la codificación a las interfaces en lugar de clases, consulte this favorite article by Allen Holub

Answer 4

Alternativamente, puede utilizar subList método:

public static <T> List<T> shrinkTo(List<T> list, int newSize) { 
    return list.subList(0, newSize - 1); 
} 

Answer 5

Mi solución:

public static void shrinkTo(List list, int newSize) { 
    int size = list.size(); 
    if (newSize >= size) return; 
    for (int i = newSize; i < size; i++) { 
     list.remove(list.size() - 1); 
    } 
} 

sólo tiene que utilizar:

shrinkTo(yourList, 6);