Analisi dettagliata della classe ArrayList [Parte 2]

Sfortunatamente, tutte le informazioni non rientrano in un articolo, quindi continuiamo a esaminare i restanti metodi della classe ArrayList. Ordina raccolta:

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

Ordina l'elenco in base a una determinata regola. Una regola di ordinamento è un'interfaccia Comparator implementata con un file compare(). L'override è necessario se la raccolta contiene oggetti della propria classe. Quando si lavora con classi standard (Integer, String e così via), l'override del confronto è solitamente necessario solo per l'ordinamento non standard. Creiamo una classe 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;
 }
}

Scriviamo un semplice comparatore che confronterà gli ID degli studenti:

class StudentIdComparator implements Comparator<student>{

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

Creiamo un elenco per gli studenti e un oggetto classe che implementa Comparator:

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

Chiamiamo il metodo sortper la nostra lista e passiamogli il comparatore:

myList.sort(comparator);

Questo trasformerà l'elenco originale [4 David, 2 Tom, 5 Rohit, 1 Paul, 3 Vishal] in [1 Paul, 2 Tom, 3 Vishal, 4 David, 5 Rohit]. Per ultimo ho lasciato un metodo molto interessante, ma usato raramente:

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

Non restituisce una nuova lista, come potrebbe sembrare, ma una vista della lista (sottolista) per la quale è stato chiamato questo metodo, in modo che entrambe le liste condividano gli elementi memorizzati. subList è un elenco completamente funzionale; funziona anche in scrittura, apportando le modifiche appropriate all'elenco genitore. Da ciò derivano ottime proprietà:

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

In questo esempio someListverranno rimossi dalla lista quattro elementi, dal terzo al settimo (non compresi). Indichiamo l'intervallo per lavorare con l'elenco e il gioco è fatto. All'interno del metodo, in sostanza, c'è una chiamata alla classe SubList, che ha le proprie implementazioni di metodi conosciuti e, come risultato dell'operazione del metodo, viene restituito un oggetto di questa classe. L'implementazione della classe stessa può essere visualizzata nel codice sorgente . Per consolidare il materiale, ti suggerisco di scrivere la tua implementazione di un array dinamico. Questo sarà molto utile in futuro. Ad esempio, presento la mia implementazione di un array dinamico solo per numeri, con commenti nel codice.

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; //записываем в конец списка новое meaning
        size++;  //увеличиваем meaning переменной размера списка
        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] instead of [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];  //сохраняем в доп. переменную meaning удаляемого element
        System.arraycopy(temp, 0, elements, 0, index);  //копируем левую часть массива до указанного индекса
        System.arraycopy(temp, index + 1, elements, index, temp.length - index - 1);  //копируем правую часть массива после указанного индекса
        size--;  //уменьшаем meaning переменной
        return value;
    }
}

Elenco delle fonti utilizzate:

1. Codice sorgente ArrayList (attuale - JDK 12);
2. La maggior parte delle illustrazioni sono state prese da qui e alcuni articoli da JavaRush;
3. Articolo su Habré .