Detaillierte Analyse der ArrayList-Klasse [Teil 2]

Leider passten nicht alle Informationen in einen Artikel, daher schauen wir uns weiterhin die verbleibenden Methoden der ArrayList-Klasse an. Sammlung sortieren:

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

Sortiert die Liste nach einer vorgegebenen Regel. Eine Sortierregel ist eine implementierte Comparator- Schnittstelle mit einer überschriebenen compare(). Das Überschreiben ist erforderlich, wenn die Sammlung Objekte einer eigenen Klasse enthält. Beim Arbeiten mit Standardklassen (Integer, String usw.) wird die Vergleichsüberschreibung normalerweise nur für nicht standardmäßige Sortierungen benötigt. Lassen Sie uns eine Klasse erstellen 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;
 }
}

Schreiben wir einen einfachen Komparator, der Studentenausweise vergleicht:

class StudentIdComparator implements Comparator<student>{

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

Erstellen wir eine Liste für Schüler und ein Klassenobjekt, das Folgendes implementiert Comparator:

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

Rufen wir die Methode sortfür unsere Liste auf und übergeben ihr den Komparator:

myList.sort(comparator);

Dadurch wird die ursprüngliche Liste [4 David, 2 Tom, 5 Rohit, 1 Paul, 3 Vishal] in [1 Paul, 2 Tom, 3 Vishal, 4 David, 5 Rohit] umgewandelt. Zum Schluss habe ich eine sehr interessante, aber selten verwendete Methode hinterlassen:

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

Es wird keine neue Liste zurückgegeben, wie es scheint, sondern eine Ansicht der Liste (Unterliste), für die diese Methode aufgerufen wurde, sodass beide Listen die gespeicherten Elemente gemeinsam nutzen. subList ist eine voll funktionsfähige Liste; sie funktioniert auch zum Schreiben und nimmt entsprechende Änderungen an der übergeordneten Liste vor. Daraus ergeben sich hervorragende Eigenschaften:

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

In diesem Beispiel someListwerden vier Elemente aus der Liste entfernt, vom dritten bis zum siebten (nicht einschließlich). Wir geben den Bereich für die Arbeit mit der Liste an und los geht's. Innerhalb der Methode erfolgt im Wesentlichen ein Aufruf der SubList-Klasse, die über eigene Implementierungen bekannter Methoden verfügt, und als Ergebnis der Methodenoperation wird ein Objekt dieser Klasse zurückgegeben. Die Implementierung der Klasse selbst kann im Quellcode eingesehen werden . Um das Material zu festigen, schlage ich vor, dass Sie Ihre eigene Implementierung eines dynamischen Arrays schreiben. Dies wird in Zukunft sehr nützlich sein. Als Beispiel präsentiere ich meine Implementierung eines dynamischen Arrays nur für Zahlen mit Kommentaren im 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; //записываем в конец списка новое Bedeutung
        size++;  //увеличиваем Bedeutung переменной размера списка
        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] anstatt [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];  //сохраняем в доп. переменную Bedeutung удаляемого Element
        System.arraycopy(temp, 0, elements, 0, index);  //копируем левую часть массива до указанного индекса
        System.arraycopy(temp, index + 1, elements, index, temp.length - index - 1);  //копируем правую часть массива после указанного индекса
        size--;  //уменьшаем Bedeutung переменной
        return value;
    }
}

Liste der verwendeten Quellen:

1. ArrayList-Quellcode (aktuell – JDK 12);
2. Die meisten Abbildungen stammen von hier und einige Artikel von JavaRush;
3. Artikel über Habré .