Statisches Array

Array ist eine lineare Datenstruktur, in der alle Elemente nacheinander angeordnet sind. Es handelt sich um eine Sammlung von Elementen des gleichen Datentyps, die an angrenzenden Speicherorten gespeichert sind.

Initialisierung

public class Array {
    private T[] self;
    private int size;
    @SuppressWarnings("unchecked")
    public Array(int size) {
        if (size 



In der Core-Array-Klasse werden wir die Größe des Arrays und ein allgemeines Grundgerüst für die Array-Initialisierung speichern. Im Konstruktor fragen wir nach der Größe des Arrays, erstellen ein Objekt und wandeln es in unser gewünschtes Array um.


  
  
  Methode festlegen




public void set(T item, int index) {
        if (index >= this.size || index 



Diese Methode fordert die Speicherung eines Elements im Array und den Index an, auf dem das Element gespeichert werden soll.


  
  
  Get-Methode




public T get(int index) {
        if (index >= this.size || index 



Get-Methode fragt nach einem Index und ruft ein Element aus diesem Index ab.


  
  
  Druckmethode




public void print() {
        for (int i = 0; i 



Die Druckmethode druckt lediglich alle Mitglieder eines Arrays in einer einzigen Zeile, wobei jedes Element durch ein Leerzeichen dazwischen getrennt wird.


  
  
  Sortiertes Array


Arrays, aber mit einer Funktionalität zum Sortieren von Elementen selbst.


  
  
  Initialisierung




public class SortedArray> {
    private T[] array;
    private int size;
    private final int maxSize;
    @SuppressWarnings("unchecked")
    public SortedArray(int maxSize) {
        if (maxSize 



In der Klasse „Sorted Array“ speichern wir die Größe des Arrays und fragen auch nach der maximalen Größe des Arrays sowie nach einem allgemeinen Grundgerüst für die Array-Initialisierung. Im Konstruktor fragen wir nach der maximalen Größe des Arrays, erstellen ein Objekt und wandeln es in unser gewünschtes Array um.


  
  
  Getter




public int length() {
        return this.size;
    }
 public int maxLength() {
        return this.maxSize;
    }
 public T get(int index) {
        if (index = this.size) {
            throw new IndexOutOfBoundsException("Index out of 
 bounds: "   index);
        }
        return this.array[index];
    }





  
  
  Einfügemethode




private int findInsertionPosition(T item) {
        int left = 0;
        int right = size - 1;
        while (left = this.maxSize) {
            throw new IllegalStateException("The array is already full");
        }

        int position = findInsertionPosition(item);

        for (int i = size; i > position; i--) {
            this.array[i] = this.array[i - 1];
        }
        this.array[position] = item;
        size  ;
    }




Einfügemethode fügt das Element in sortierter Form an seiner Position ein.


  
  
  Löschmethode




    public void delete(T item) {
        int index = binarySearch(item);
        if (index == -1) {
            throw new IllegalArgumentException("Unable to delete element "   item   ": the entry is not in the array");
        }

        for (int i = index; i 




  
  
  Suchmethoden




private int binarySearch(T target) {
        int left = 0;
        int right = size - 1;
        while (left 




  
  
  Traverse-Methode




public void traverse(Callback callback) {
        for (int i = 0; i 




  
  
  Rückrufschnittstelle




public interface Callback {
        void call(T item);
    }





  
  
  Verwendung der Callback-Schnittstelle beim Traversieren




public class UppercaseCallback implements UnsortedArray.Callback {
    @Override
    public void call(String item) {
        System.out.println(item.toUpperCase());
    }
}





  
  
  Unsortiertes Array


Von oben ist es fast dasselbe

Initialisierung und Getter sind gleich.


  
  
  Einfügemethode




public void insert(T item) {
        if (this.size >= this.maxSize) {
            throw new IllegalStateException("The array is already full");
        } else {
            this.self[this.size] = item;
            this.size  ;
        }
    }




Die Löschmethode ist ebenfalls dieselbe.


  
  
  Suchmethode




public Integer find(T target) {
        for (int i = 0; i 




  
  
  Dynamisches Array


Dynamische Arrays sind wie Array-Listen oder Listen.


  
  
  Initialisierung




public class DynamicArray {
    private T[] array;
    private int size;
    private int capacity;

    @SuppressWarnings("unchecked")
    public DynamicArray(int initialCapacity) {
        if (initialCapacity 




  
  
  Methode einfügen




private void resize(int newCapacity) {
        @SuppressWarnings("unchecked")
        T[] newArray = (T[]) new Object[newCapacity];
        for (int i = 0; i = capacity) {
            resize(2 * capacity);
        }
        array[size  ] = item;
    }





  
  
  Methode löschen




public void delete(T item) {
        int index = find(item);
        if (index == -1) {
            throw new IllegalArgumentException("Item not found: "   item);
        }

        for (int i = index; i  1 && size 



Alles andere ist gleich.

Ich hoffe, das hilft bei der Arbeit mit Arrays. Viel Glück!