O ArrayList é uma estrutura de dados baseada em arrays que permite adicionar, remover e acessar elementos de forma eficiente. Diferente dos arrays tradicionais, o ArrayList cresce dinamicamente conforme novos elementos são adicionados.

Implementação do ArrayList em TypeScript

Abaixo está a implementação completa de um ArrayList genérico em TypeScript:

export class ArrayList {
  private items: T[];
  private map: Map;

  constructor(initialCapacity: number = 0) {
    this.items = new Array(initialCapacity);
    this.map = new Map();
  }

  add(element: T): void {
    this.items.push(element);
  }

  addAll(elements: T[]): void {
    this.items.push(...elements);
  }

  get(index: number): T | undefined {
    if (index < 0 || index >= this.items.length) {
      throw new Error('Index out of bounds');
    }
    return this.items[index];
  }

  set(index: number, element: T): void {
    if (index < 0 || index >= this.items.length) {
      throw new Error('Index out of bounds');
    }
    this.items[index] = element;
  }

  remove(index: number): T | undefined {
    if (index < 0 || index >= this.items.length) {
      throw new Error('Index out of bounds');
    }
    return this.items.splice(index, 1)[0];
  }

  removeElement(element: T): boolean {
    const index = this.items.indexOf(element);
    if (index !== -1) {
      this.items.splice(index, 1);
      return true;
    }
    return false;
  }

  size(): number {
    return this.items.length;
  }

  isEmpty(): boolean {
    return this.items.length === 0;
  }

  contains(element: T): boolean {
    return this.items.includes(element);
  }

  clear(): void {
    this.items = [];
  }

  toArray(): T[] {
    return [...this.items];
  }

  indexOf(element: T): number {
    return this.items.indexOf(element);
  }

  lastIndexOf(element: T): number {
    return this.items.lastIndexOf(element);
  }

  subList(fromIndex: number, toIndex: number): T[] {
    if (fromIndex < 0 || toIndex > this.items.length || fromIndex > toIndex) {
      throw new Error('Index out of bounds');
    }
    return this.items.slice(fromIndex, toIndex);
  }

  forEach(callback: (element: T, index: number) => void): void {
    this.items.forEach(callback);
  }

  sort(compareFn?: (a: T, b: T) => number): void {
    this.items.sort(compareFn);
  }

  setKeyValue(key: string, value: T): void {
    this.map.set(key, value);
  }

  getValue(key: string): T | undefined {
    return this.map.get(key);
  }

  removeKey(key: string): boolean {
    return this.map.delete(key);
  }

  hasKey(key: string): boolean {
    return this.map.has(key);
  }

  clearMap(): void {
    this.map.clear();
  }

  mapSize(): number {
    return this.map.size;
  }
}

Explicação dos Métodos:

  • add(element: T): Adiciona um elemento à lista.

  • addAll(elements: T[]): Adiciona múltiplos elementos de uma vez.

  • get(index: number): Retorna o elemento em um índice específico.

  • set(index: number, element: T): Atualiza o elemento em um índice.

  • remove(index: number): Remove um elemento pelo índice.

  • removeElement(element: T): Remove um elemento específico.

  • size(): Retorna o tamanho atual da lista.

  • isEmpty(): Verifica se a lista está vazia.

  • contains(element: T): Verifica se um elemento está presente na lista.

  • clear(): Remove todos os elementos da lista.

  • toArray(): Retorna a lista como um array.

  • indexOf(element: T): Retorna o índice da primeira ocorrência do elemento.

  • lastIndexOf(element: T): Retorna o índice da última ocorrência do elemento.

  • subList(fromIndex: number, toIndex: number): Retorna uma sublista entre os índices fornecidos.

  • forEach(callback): Itera sobre os elementos da lista.

  • sort(compareFn): Ordena os elementos com base em uma função opcional de comparação.

Exemplo de Uso:

const list = new ArrayList();
list.add(10);
list.add(20);
list.add(30);
console.log(list.get(1)); // Saída: 20
list.remove(1);
console.log(list.toArray()); // Saída: [10, 30]

Repo no Github: https://github.com/williamkoller/array-list

Conclusão

Essa implementação do ArrayList em TypeScript oferece uma alternativa flexível para manipular listas dinâmicas de maneira eficiente. O uso de tipagem genérica permite que a lista funcione com qualquer tipo de dado, tornando-a extremamente versátil.

Se gostou do artigo, compartilhe com outros desenvolvedores! 🚀