Análisis detallado de la clase ArrayList [Parte 2]

Desafortunadamente, toda la información no cabía en un solo artículo, por lo que continuamos analizando los métodos restantes de la clase ArrayList. Ordenar colección:

public void sort(Comparator< ? super E> c)

Ordena la lista según una regla determinada. Una regla de clasificación es una interfaz Comparator implementada con un valor anulado compare(). La anulación es necesaria si la colección contiene objetos de su propia clase. Cuando se trabaja con clases estándar (Integer, String, etc.), la anulación de comparación generalmente solo es necesaria para la clasificación no estándar. Creemos una clase Student:

class Student{
 String student_name;
 int id;

 Student(int id, String  student_name){
  this.id = id;
  this.student_name = student_name;
 }

 public String toString(){
  return id + " " + student_name;
 }
}

Escribamos un comparador simple que compare las identificaciones de los estudiantes:

class StudentIdComparator implements Comparator<student>{

 public int compare(Student e1, Student e2) {
  return e1.id.compareTo(e2.id);
 }
}

Creemos una lista para estudiantes y un objeto de clase que implemente Comparator:

ArrayList<Student> myList = new ArrayList<> ();
StudentIdComparator comparator = new StudentIdComparator();

Llamemos al método sortde nuestra lista y le pasemos el comparador:

myList.sort(comparator);

Esto convertirá la lista original [4 David, 2 Tom, 5 Rohit, 1 Paul, 3 Vishal] en [1 Paul, 2 Tom, 3 Vishal, 4 David, 5 Rohit]. Para el final dejé un método muy interesante, pero poco utilizado:

public List<E> subList(int fromIndex, int toIndex)

No devuelve una lista nueva, como podría parecer, sino una vista de la lista (sublista) para la que se llamó este método, de modo que ambas listas compartirán los elementos almacenados. subList es una lista completamente funcional; también funciona para escribir, realizando los cambios apropiados en la lista principal. De esto se derivan excelentes propiedades:

someList.subList(3, 7).clear();

En este ejemplo, someListse eliminarán cuatro elementos de la lista, del tercero al séptimo (sin incluir). Indicamos el rango para trabajar con la lista y listo. Dentro del método, en esencia, hay una llamada a la clase SubList, que tiene sus propias implementaciones de métodos conocidos, y como resultado de la operación del método, se devuelve un objeto de esta clase. La implementación de la clase en sí se puede ver en el código fuente . Para consolidar el material, le sugiero que escriba su propia implementación de una matriz dinámica. Esto será muy útil en el futuro. Como ejemplo, presento mi implementación de una matriz dinámica solo para números, con comentarios en el código.

public class IntegerArrayList {

    private int [] elements;  //массив, для хранения чисел
    private int size;  //поле-счетчик, которое указывает на количество элементов в массиве
    private static final int DEFAULT_CAPACITY = 10;  //размер массива по умолчанию

    //конструктор без параметров, который создает массив на 10 элементов, если размер не был указан
    public IntegerArrayList(){  //
        this.elements = new int[DEFAULT_CAPACITY];
    }

    //создает массив указанной емкости
    public IntegerArrayList(int initialCapacity){
        if (initialCapacity >= 0){
            this.elements = new int[initialCapacity];
        }
        else {
            throw new IllegalStateException("Capacity can't be less than 0!");
        }
    }

    //получает элемент по указанному индексу
    public int get(int index){
        isIndexExist(index);  //проверка корректности введенного индекса
        return elements[index];
    }

    //возвращает количество элементов в списке
    public int size (){
        return size;
    }

    //добавляем элемент в конец списка
    public boolean add(int value){
        if (size == elements.length){  //если в массиве места нет
            elements = increaseCapacity(); //вызываем метод, который отвечает за увеличение массива
        }
        elements[size] = value; //записываем в конец списка новое significado
        size++;  //увеличиваем significado переменной размера списка
        return true;
    }

    //дополнительный закрытый метод для увеличения емкости массива
    private int [] increaseCapacity(){
        int [] temp = new int[(elements.length * 2)];  //создаем новый массив большего размера
        System.arraycopy(elements, 0, temp, 0, elements.length);  //копируем в новый массив элементы из старого массива
        return temp;
    }

    //устанавливает элемент на указанную позицию
    public int set(int value, int index){
        isIndexExist(index);
        int temp = elements[index];
        elements[index] = value;
        return temp;
    }

    //переопределил метод для красивого вывода списка на экран, иначе будут выводиться значения незаполненных ячеек [1, 10] en lugar de [1, 10, 0, 0...]
    @Override
    public String toString(){
        int [] temp = new int[size];
        System.arraycopy(elements, 0, temp, 0, size);
        return Arrays.toString(temp);
    }

    //проверяем индексы, не выходят ли они за границы массива
    private int isIndexExist(int index){
        if (index >= size || index < 0){
            throw new IndexOutOfBoundsException("Element can't be found! "
                    + "Number of elements in array = " + size
                    + ". Total size of array = " + elements.length);
        }
        return index;
    }

    //проверяем, есть ли элементы в списке
    public boolean isEmpty(){
        return (size == 0);
    }

    //удаляем элемент по индексу
    public int remove (int index){
        isIndexExist(index);  //проверяем индекс
        int [] temp = elements;  //во временный массив заносим ссылку на текущий массив
        elements = new int [temp.length-1];  //полю elements присваиваем ссылку на новый массив размером меньше на 1
        int value = temp[index];  //сохраняем в доп. переменную significado удаляемого elemento
        System.arraycopy(temp, 0, elements, 0, index);  //копируем левую часть массива до указанного индекса
        System.arraycopy(temp, index + 1, elements, index, temp.length - index - 1);  //копируем правую часть массива после указанного индекса
        size--;  //уменьшаем significado переменной
        return value;
    }
}

Lista de fuentes utilizadas:

1. Código fuente de ArrayList (actual - JDK 12);
2. La mayoría de las ilustraciones fueron tomadas de aquí y algunos artículos de JavaRush;
3. Artículo sobre Habré .