Matriz estática

La matriz es una estructura de datos lineal donde todos los elementos están organizados secuencialmente. Es una colección de elementos del mismo tipo de datos almacenados en memoria contigua ubicaciones.

Inicialización

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



En Core Array Class, almacenaremos el tamaño de la matriz y un esqueleto general para la inicialización de la matriz. En el constructor, solicitamos el tamaño de la matriz y creamos un objeto y escribimos para convertirlo en nuestra matriz deseada.


  
  
  Establecer método




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



Este método solicita que un elemento se almacene en una matriz y un índice en el que se debe almacenar el elemento.


  
  
  Obtener método




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



El método Get solicita un índice y recupera el elemento de ese índice.


  
  
  Método de impresión




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



El método de impresión consiste simplemente en imprimir todos los miembros de una matriz en una sola línea con un espacio que separa cada elemento entre ellos.


  
  
  Matriz ordenada


Matrices pero que tienen una funcionalidad para ordenar elementos en sí.


  
  
  Inicialización




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



 En la clase de matriz ordenada, almacenaremos el tamaño de la matriz y también solicitaremos el tamaño máximo de la matriz y un esqueleto general para la inicialización de la matriz. En el constructor, solicitamos el tamaño máximo de la matriz, creamos un objeto y lo tipificamos en nuestra matriz deseada.


  
  
  captadores




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





  
  
  Método de inserción




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




El método Insertar inserta el elemento en su posición en forma ordenada.


  
  
  Método de eliminación




    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 




  
  
  Métodos de búsqueda




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




  
  
  Método transversal




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




  
  
  Interfaz de devolución de llamada




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





  
  
  Uso de la interfaz de devolución de llamada al atravesar




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





  
  
  Matriz sin clasificar


Es casi lo mismo desde arriba

La inicialización y los captadores son los mismos.


  
  
  Método de inserción




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




El método de eliminación también es el mismo


  
  
  Método de búsqueda




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




  
  
  Matriz dinámica


Los Arrays Dinámicos son como listas o listas de arrays.


  
  
  Inicialización




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

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




  
  
  Método de inserción




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





  
  
  Eliminar método




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 



Todo lo demás es igual.

Espero que esto ayude a trabajar con matrices. ¡Buena suerte!