JS 模擬 Java 動態數組（類）

 Code：

/**
 * 動態數組
 * @class
 */
var DArray = (function() {
  /**
   * 數據數組
   * @type {*[]}
   */
  let data;

  /**
   * 數組中的元素個數
   * @type {number}
   */
  let size;

  /**
   * 調整數組容器大小
   * @param {number} new_capacity
   */
  const resize = new_capacity => {
    const newData = new Array(new_capacity);
    for (let i = 0; i < size; i++) {
      newData[i] = data[i];
    }
    data = newData;
  };

  /**
   * 內部動態數組類
   * @class
   */
  class _DArray {
    /**
     * 構造器
     * @constructor
     * @param {number} capacity
     */
    constructor(capacity = 10) {
      data = new Array(capacity);
      size = 0;
    }

    /**
     * 獲取數組容量
     * @return {number} 
     */
    get_capacity() {
      return data.length;
    }

    /**
     * 獲取現有元素的個數
     * @return {number} 
     */
    get_size() {
      return size;
    }

    /**
     * 個數是否爲空
     * @return {boolean} 
     */
    is_empty() {
      return size === 0;
    }

    /**
     * 往指定位置添加元素
     * @param {number} index 
     * @param {*} newEl 
     */
    add(index, newEl) {
      if (index > size || index < 0) {
        throw new RangeError('操作越界！');
      }

      if (size === data.length) {
        resize(2 * data.length);
      }

      for (let i = size - 1; i >= index; i--) {
        data[i + 1] = data[i];
      }

      data[index] = newEl;

      size++;
    }

    /**
     * 插入到數組尾部
     * @param {*} el 
     */
    insert_to_tail(el) {
      this.add(size, el);
    }

    /**
     * 插入到數組頭部
     * @param {*} el 
     */
    insert_to_head(el) {
      this.add(0, el);
    }

    /**
     * 插入到數組尾部
     * @param {number} index 
     */
    get(index) {
      if (index >= size || index < 0) {
        throw new RangeError('操作越界！');
      }

      return data[index];
    }

    /**
     * 更新設置值
     * @param {number} index 
     * @param {*} el 
     */
    set(index, el) {
      if (index >= size || index < 0) {
        throw new RangeError('操作越界！');
      }

      data[index] = el;
    }

    /**
     * 查找元素的位置索引
     * @param {*} target 
     * @return {number} 
     */
    find_index(target) {
      for (let i = 0; i < size; i++) {
        if (data[i] === target) {
          return i;
        }
      }

      return -1;
    }

    /**
     * 是否包含某個元素
     * @param {*} el 
     * @return {boolean} 
     */
    contains(el) {
      for (const item of data) {
        if (item === el) {
          return true;
        }
      }

      return false;
    }

    /**
     * 移除某個位置上的元素並返回
     * @param {number} index 
     * @return {*} 
     */
    remove(index) {
      if (index >= size || index < 0) {
        throw new RangeError('操作越界！');
      }

      const target = data[index];
      for (let i = index + 1; i < size; i++) {
        data[i - 1] = data[i];
      }
      size--;
      data[size] = void 0;

      if (size === data.length / 2) {
        resize(data.length / 2);
      }

      return target;
    }

    /**
     * 移除頭部元素
     * @return {*}
     */
    remove_head() {
      return this.remove(0);
    }

    /**
     * 移除尾部元素
     * @return {*}
     */
    remove_tail() {
      return this.remove(size - 1);
    }

    /**
     * 刪除特定元素
     * @param {*} el 
     * @return {boolean} 
     */
    remove_element(el) {
      const targetIndex = this.find_index(el);
      if (targetIndex > -1) {
        this.remove(targetIndex);
        return true;
      }
      return false;
    }

    /**
     * 字符串化輸出
     * @return {string} 
     */
    to_string() {
      let str = `Array: ${size}(size) - ${data.length}(capacity), [${size > 0 ? data[0] : ''}`;
      for (let i = 1; i < size; i++) {
        str += (',' + data[i]);
      }
      str += ']';
      return str;
    }
  }

  return _DArray;
})();

：JS數組本身就是一個動態對象