Analyse détaillée de la classe ArrayList [Partie 2]

Malheureusement, toutes les informations ne rentrent pas dans un seul article, nous continuons donc à examiner les méthodes restantes de la classe ArrayList. Trier la collection :

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

Trie la liste selon une règle donnée. Une règle de tri est une interface Comparator implémentée avec un compare(). La substitution est nécessaire si la collection contient des objets de sa propre classe. Lorsque vous travaillez avec des classes standard (Integer, String, etc.), le remplacement de comparaison n'est généralement nécessaire que pour le tri non standard. Créons une classeStudent :

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;
 }
}

Écrivons un comparateur simple qui comparera les identifiants des étudiants :

class StudentIdComparator implements Comparator<student>{

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

Créons une liste pour les étudiants et un objet de classe qui implémenteComparator :

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

Appelons la méthode sortde notre liste et passons-lui le comparateur :

myList.sort(comparator);

Cela transformera la liste originale [4 David, 2 Tom, 5 Rohit, 1 Paul, 3 Vishal] en [1 Paul, 2 Tom, 3 Vishal, 4 David, 5 Rohit]. Pour finir, j'ai laissé une méthode très intéressante, mais rarement utilisée :

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

Elle ne renvoie pas une nouvelle liste, comme cela peut paraître, mais une vue de la liste (sous-liste) pour laquelle cette méthode a été appelée, afin que les deux listes partagent les éléments stockés. subList est une liste entièrement fonctionnelle ; elle fonctionne également pour l'écriture, en apportant les modifications appropriées à la liste parent. D'excellentes propriétés en découlent :

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

Dans cet exemple, someListquatre éléments seront supprimés de la liste, du troisième au septième (non inclus). Nous indiquons la plage pour travailler avec la liste et c'est parti. À l'intérieur de la méthode, il y a essentiellement un appel à la classe SubList, qui a ses propres implémentations de méthodes connues, et à la suite du fonctionnement de la méthode, un objet de cette classe est renvoyé. L'implémentation de la classe elle - même peut être visualisée dans le code source . Pour consolider le matériel, je vous suggère d'écrire votre propre implémentation d'un tableau dynamique. Cela sera très utile à l'avenir. A titre d'exemple, je présente mon implémentation d'un tableau dynamique pour les nombres uniquement, avec des commentaires dans le code.

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;
    }
}

Liste des sources utilisées :

1. Code source d'ArrayList (actuel - JDK 12) ;
2. La plupart des illustrations sont tirées d'ici et certains articles de JavaRush ;
3. Article sur Habré .