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数组本身就是一个动态对象