Detalyadong pagsusuri ng klase ng ArrayList [Bahagi 2]

Sa kasamaang palad, ang lahat ng impormasyon ay hindi magkasya sa isang artikulo, kaya patuloy naming tinitingnan ang natitirang mga pamamaraan ng klase ng ArrayList. Pagbukud-bukurin ang koleksyon:

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

Pinagbukud-bukod ang listahan ayon sa isang ibinigay na panuntunan. Ang isang panuntunan sa pag-uuri ay isang ipinatupad na interface ng Comparator na may na-override na compare(). Kinakailangan ang pag-override kung ang koleksyon ay naglalaman ng mga bagay ng sarili nitong klase. Kapag nagtatrabaho sa mga karaniwang klase (Integer, String, at iba pa), ang paghahambing na override ay karaniwang kailangan lamang para sa hindi karaniwang pag-uuri. Gumawa tayo ng klase 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;
 }
}

Sumulat tayo ng isang simpleng comparator na maghahambing ng mga student id:

class StudentIdComparator implements Comparator<student>{

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

Gumawa tayo ng listahan para sa mga mag-aaral at isang object ng klase na nagpapatupad ng Comparator:

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

Tawagan natin ang pamamaraan sortpara sa aming listahan at ipasa ang comparator dito:

myList.sort(comparator);

Gagawin nito ang orihinal na listahan [4 David, 2 Tom, 5 Rohit, 1 Paul, 3 Vishal] sa [1 Paul, 2 Tom, 3 Vishal, 4 David, 5 Rohit]. Sa huli ay nag-iwan ako ng isang napaka-interesante, ngunit bihirang ginagamit na paraan:

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

Hindi ito nagbabalik ng isang bagong listahan, tulad ng maaaring mukhang, ngunit isang view ng listahan (sublist) kung saan tinawag ang pamamaraang ito, upang ang parehong mga listahan ay magbahagi ng mga nakaimbak na elemento. Ang subList ay isang fully functional na listahan; gumagana rin ito para sa pagsusulat, paggawa ng naaangkop na mga pagbabago sa listahan ng magulang. Ang mga mahuhusay na katangian ay sumusunod dito:

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

Sa halimbawang ito, someListapat na elemento ang aalisin sa listahan, mula sa ikatlo hanggang sa ikapito (hindi kasama). Ipinapahiwatig namin ang hanay para sa pagtatrabaho sa listahan at umalis na kami. Sa loob ng pamamaraan, sa esensya, mayroong isang tawag sa klase ng SubList, na may sariling mga pagpapatupad ng mga kilalang pamamaraan, at bilang resulta ng pagpapatakbo ng pamamaraan, ang isang bagay ng klase na ito ay ibinalik. Ang pagpapatupad ng klase mismo ay maaaring matingnan sa source code . Upang pagsamahin ang materyal, iminumungkahi kong isulat mo ang iyong sariling pagpapatupad ng isang dynamic na array. Ito ay magiging lubhang kapaki-pakinabang sa hinaharap. Bilang isang halimbawa, ipinakita ko ang aking pagpapatupad ng isang dynamic na array para sa mga numero lamang, na may mga komento sa 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;
    }
}

Listahan ng mga mapagkukunang ginamit:

1. ArrayList source code (kasalukuyan - JDK 12);
2. Karamihan sa mga ilustrasyon ay kinuha mula rito at ilang artikulo mula sa JavaRush;
3. Artikulo sa Habré .