O que é um ArrayList?

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!

Mar 18, 2025 - 18:01

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!