初版：

  1. public interface ArrayList<E> {
  2.     public int size(); // 元素的数量
  4.     public boolean isEmpty(); // 是否为空
  6.     public boolean contains(int element); // 是否包含某个元素
  8.     public void add(int element); // 添加元素到最后面
  10.     public int get(int index); // 返回index位置对应的元素
  12.     public int set(int index, int element); // 设置index位置的元素
  14.     public void add(int index, int element); // 往index位置添加元素
  16.     public int remove(int index); // 删除index位置对应的元素
  18.     public int indexOf(int element); // 查看元素的位置
  20.     public void clear(); // 清除所有元素
  21. }
  1. package com.test;
  3. @SuppressWarnings("unchecked")
  4. public class MyArrayList<E> implements ArrayList<E> {
  6.     /**
  7.      * 元素的数量
  8.      */
  9.     private int size;
  10.     /**
  11.      * 元素的原始数组，存放变动元素的数组
  12.      */
  13.     private int[] elements;
  15.     /**
  16.      * 默认容量
  17.      */
  18.     private static final int DEFAULT_CAPACITY = 10;
  19.     /**
  20.      * 元素错误值
  21.      */
  22.     private static final int ELEMENT_NOT_FOUND = -1;
  24.     /**
  25.      * 构造函数，创建一个固定大小 数组
  26.      * 
  27.      * @param capaticy 容量
  28.      */
  29.     public MyArrayList(int capaticy) {
  30.         // 固定数组
  31.         // elements = new int[capaticy];
  32.         // 修改为动态数组，即如果容量小于默认值，那么直接使用默认10大小的容量
  33.         // 否则使用大于10默认值的容量
  34.         // 以此来创建灵活多变的数组
  35.         capaticy = (capaticy < DEFAULT_CAPACITY) ? DEFAULT_CAPACITY : capaticy;
  36.         elements = new int[capaticy];
  37.     }
  39.     /**
  40.      * 默认一个10位大小的整数型数组
  41.      */
  42.     public MyArrayList() {
  43.         // elements = new int[10];
  44.         // elements = new int[DEFAULT_CAPACITY];
  45.         // 调用构造函数
  46.         this(DEFAULT_CAPACITY);
  47.     }
  49.     /**
  50.      * 元素的数量
  51.      */
  52.     @Override
  53.     public int size() {
  54.         return size;
  55.     }
  57.     /**
  58.      * 是否为空
  59.      */
  60.     @Override
  61.     public boolean isEmpty() {
  62.         return size == 0;
  63.     }
  65.     /**
  66.      * 是否包含某个元素
  67.      */
  68.     @Override
  69.     public boolean contains(int element) {
  70.         // 查找元素索引存在吗，不存在则false，存在为true
  71.         return indexOf(element) != ELEMENT_NOT_FOUND;
  72.     }
  74.     /**
  75.      * 添加元素到最后面
  76.      */
  77.     @Override
  78.     public void add(int element) {
  79.         // elements[size++] = element;
  80.         // size++;
  81.         add(this.size, element);
  82.     }
  84.     /**
  85.      * 返回index位置对应的元素
  86.      * 
  87.      * @param index 索引
  88.      */
  89.     @Override
  90.     public int get(int index) {
  91.         // 如果索引小于0或者索引大于元素的数量
  92. //        if (index < 0 || index >= size) {
  93. //            // 抛出下标越界异常，提示信息：索引值，list里存放的元素数量
  94. //            throw new IndexOutOfBoundsException("index：" + index + ",size：" + size);
  95. //        }
  96.         rangeCheck(index);
  97.         // 返回对应索引位置的元素数组
  98.         return elements[index];
  99.     }
  101.     /**
  102.      * 设置index位置的元素
  103.      * 
  104.      * @param index   修改索引
  105.      * @param element 修改元素值
  106.      */
  107.     @Override
  108.     public int set(int index, int element) {
  109.         // 如果索引小于0或者索引大于元素的数量
  110. //        if (index < 0 || index >= size) {
  111. //            // 抛出下标越界异常，提示信息：索引值，list里存放的元素数量
  112. //            throw new IndexOutOfBoundsException("index：" + index + ",size：" + size);
  113. //        }
  114.         rangeCheck(index);
  115.         // 拿到元素组对应的值
  116.         int old = elements[index];
  117.         // 将要修改元素值赋值给原元素值
  118.         elements[index] = element;
  119.         // 返回结果-被修改后的元素值
  120.         return old;
  121.     }
  123.     /**
  124.      * 往index位置添加元素
  125.      */
  126.     @Override
  127.     public void add(int index, int element) {
  128. //        if (index < 0 || index > size) {
  129. //            // 抛出下标越界异常，提示信息：索引值，list里存放的元素数量
  130. //            throw new IndexOutOfBoundsException("index：" + index + ",size：" + size);
  131. //        }
  132.         rangeCheckForAdd(index);
  134.         ensureCapacity(size + 1);
  136.         for (int i = size - 1; i >= index; i--) {
  137.             elements[i + 1] = elements[i];
  138.         }
  139.         elements[index] = element;
  140.         size++;
  141.     }
  143.     /**
  144.      * 扩容
  145.      * 
  146.      * @param capacity
  147.      */
  148.     private void ensureCapacity(int capacity) {
  149.         int oldCapacity = elements.length;
  150.         if (oldCapacity >= capacity) {
  151.             return;
  152.         }
  154.         int newCapactiy = oldCapacity + (oldCapacity >> 2);
  155.         int[] newElements = new int[newCapactiy];
  156.         for (int i = 0; i < elements.length; i++) {
  157.             newElements[i] = elements[i];
  158.         }
  159.         elements = newElements;
  160.     }
  162.     /**
  163.      * 删除index位置对应的元素
  164.      */
  165.     @Override
  166.     public int remove(int index) {
  167.         // 如果索引小于0或者索引大于元素的数量
  168. //        if (index < 0 || index >= size) {
  169. //            // 抛出下标越界异常，提示信息：索引值，list里存放的元素数量
  170. //            throw new IndexOutOfBoundsException("index：" + index + ",size：" + size);
  171. //        }
  172.         rangeCheck(index);
  173.         //
  174.         int old = elements[index];
  175.         for (int i = index + 1; i <= size - 1; i++) {
  176.             elements[i - 1] = elements[i];
  177.             size--;
  178.         }
  179.         return old;
  180.     }
  182.     /**
  183.      * 查看元素的位置
  184.      */
  185.     @Override
  186.     public int indexOf(int element) {
  187.         // 遍历元素数组里面的所有值
  188.         for (int i = 0; i < size; i++) {
  189.             // 如果该元素值和查询元素值相等
  190.             if (elements[i] == element) {
  191.                 // 返回该元素索引
  192.                 return i;
  193.             }
  194.         }
  195.         // 否则，返回 -1
  196.         return ELEMENT_NOT_FOUND;
  197.     }
  199.     /**
  200.      * 清除所有元素
  201.      */
  202.     @Override
  203.     public void clear() {
  204.         // 不清空数组，保留数组的内存，方便下次添加使用，避免重新创建数组，减少栈堆消耗
  205.         size = 0;
  206.     }
  208.     @Override
  209.     public String toString() {
  210.         // 打印格式：[100,50,101]
  211.         StringBuilder builder = new StringBuilder();
  212.         builder.append("size = ").append(size).append(", body = [");
  213.         for (int i = 0; i < size; i++) {
  214.             if (i != 0) {
  215.                 builder.append(", ");
  216.             }
  217.             builder.append(elements[i]);
  218.         }
  219.         builder.append("]");
  220.         return builder.toString();
  221.     }
  223.     private void outOfBounds(int index) {
  224.         throw new IndexOutOfBoundsException("Index:" + index + ", Size:" + size);
  225.     }
  227.     private void rangeCheck(int index) {
  228.         if (index < 0 || index >= size) {
  229.             outOfBounds(index);
  230.         }
  231.     }
  233.     private void rangeCheckForAdd(int index) {
  234.         if (index < 0 || index > size) {
  235.             outOfBounds(index);
  236.         }
  237.     }
  238. }

最终版：

  1. public interface ArrayList2<E> {
  2.     public int size(); // 元素的数量
  4.     public boolean isEmpty(); // 是否为空
  6.     public boolean contains(E element); // 是否包含某个元素
  8.     public void add(E element); // 添加元素到最后面
  10.     public E get(int index); // 返回index位置对应的元素
  12.     public E set(int index, E element); // 设置index位置的元素
  14.     public void add(int index, E element); // 往index位置添加元素
  16.     public E remove(int index); // 删除index位置对应的元素
  18.     public int indexOf(E element); // 查看元素的位置
  20.     public void clear(); // 清除所有元素
  21. }
  1. @SuppressWarnings("unchecked")
  2. public class MyArrayList2<E> implements ArrayList2<E> {
  4.     /**
  5.      * 元素的数量
  6.      */
  7.     private int size;
  8.     /**
  9.      * 元素的原始数组，存放变动元素的数组
  10.      */
  11.     private E[] elements;
  13.     /**
  14.      * 默认容量
  15.      */
  16.     private static final int DEFAULT_CAPACITY = 10;
  17.     /**
  18.      * 元素错误值
  19.      */
  20.     private static final int ELEMENT_NOT_FOUND = -1;
  22.     /**
  23.      * 构造函数，创建一个固定大小 数组
  24.      * 
  25.      * @param capaticy 容量
  26.      */
  27.     public MyArrayList2(int capaticy) {
  28.         // 固定数组
  29.         // elements = new int[capaticy];
  30.         // 修改为动态数组，即如果容量小于默认值，那么直接使用默认10大小的容量
  31.         // 否则使用大于10默认值的容量
  32.         // 以此来创建灵活多变的数组
  33.         capaticy = (capaticy < DEFAULT_CAPACITY) ? DEFAULT_CAPACITY : capaticy;
  34.         elements = (E[]) new Object[capaticy];
  35.     }
  37.     /**
  38.      * 默认一个10位大小的整数型数组
  39.      */
  40.     public MyArrayList2() {
  41.         // elements = new int[10];
  42.         // elements = new int[DEFAULT_CAPACITY];
  43.         // 调用构造函数
  44.         this(DEFAULT_CAPACITY);
  45.     }
  47.     /**
  48.      * 元素的数量
  49.      */
  50.     @Override
  51.     public int size() {
  52.         return size;
  53.     }
  55.     /**
  56.      * 是否为空
  57.      */
  58.     @Override
  59.     public boolean isEmpty() {
  60.         return size == 0;
  61.     }
  63.     /**
  64.      * 是否包含某个元素
  65.      */
  66.     @Override
  67.     public boolean contains(E element) {
  68.         // 查找元素索引存在吗，不存在则false，存在为true
  69.         return indexOf(element) != ELEMENT_NOT_FOUND;
  70.     }
  72.     /**
  73.      * 添加元素到最后面
  74.      */
  75.     @Override
  76.     public void add(E element) {
  77.         // elements[size++] = element;
  78.         // size++;
  79.         add(this.size, element);
  80.     }
  82.     /**
  83.      * 返回index位置对应的元素
  84.      * 
  85.      * @param index 索引
  86.      */
  87.     @Override
  88.     public E get(int index) {
  89.         // 如果索引小于0或者索引大于元素的数量
  90. //        if (index < 0 || index >= size) {
  91. //            // 抛出下标越界异常，提示信息：索引值，list里存放的元素数量
  92. //            throw new IndexOutOfBoundsException("index：" + index + ",size：" + size);
  93. //        }
  94.         rangeCheck(index);
  95.         // 返回对应索引位置的元素数组
  96.         return elements[index];
  97.     }
  99.     /**
  100.      * 设置index位置的元素
  101.      * 
  102.      * @param index   修改索引
  103.      * @param element 修改元素值
  104.      */
  105.     @Override
  106.     public E set(int index, E element) {
  107.         // 如果索引小于0或者索引大于元素的数量
  108. //        if (index < 0 || index >= size) {
  109. //            // 抛出下标越界异常，提示信息：索引值，list里存放的元素数量
  110. //            throw new IndexOutOfBoundsException("index：" + index + ",size：" + size);
  111. //        }
  112.         rangeCheck(index);
  113.         // 拿到元素组对应的值
  114.         E old = elements[index];
  115.         // 将要修改元素值赋值给原元素值
  116.         elements[index] = element;
  117.         // 返回结果-被修改后的元素值
  118.         return old;
  119.     }
  121.     /**
  122.      * 往index位置添加元素
  123.      */
  124.     @Override
  125.     public void add(int index, E element) {
  126. //        if (index < 0 || index > size) {
  127. //            // 抛出下标越界异常，提示信息：索引值，list里存放的元素数量
  128. //            throw new IndexOutOfBoundsException("index：" + index + ",size：" + size);
  129. //        }
  130.         rangeCheckForAdd(index);
  132.         ensureCapacity(size + 1);
  134.         for (int i = size - 1; i >= index; i--) {
  135.             elements[i + 1] = elements[i];
  136.         }
  137.         elements[index] = element;
  138.         size++;
  139.     }
  141.     /**
  142.      * 扩容
  143.      * 
  144.      * @param capacity
  145.      */
  146.     private void ensureCapacity(int capacity) {
  147.         int oldCapacity = elements.length;
  148.         if (oldCapacity >= capacity) {
  149.             return;
  150.         }
  152.         int newCapactiy = oldCapacity + (oldCapacity >> 1);
  153.         E[] newElements = (E[]) new Object[newCapactiy];
  154.         for (int i = 0; i < size; i++) {
  155.             newElements[i] = elements[i];
  156.         }
  157.         elements = newElements;
  158.     }
  160.     /**
  161.      * 删除index位置对应的元素
  162.      */
  163.     @Override
  164.     public E remove(int index) {
  165.         // 如果索引小于0或者索引大于元素的数量
  166. //        if (index < 0 || index >= size) {
  167. //            // 抛出下标越界异常，提示信息：索引值，list里存放的元素数量
  168. //            throw new IndexOutOfBoundsException("index：" + index + ",size：" + size);
  169. //        }
  170.         rangeCheck(index);
  171.         // 获取该索引下的元素值
  172.         E old = elements[index];
  173.         // 从索引下一个位置处开始，到数组的数量遍历
  174.         for (int i = index + 1; i <= size - 1; i++) {
  175.             elements[i - 1] = elements[i];
  176.             size--;
  177.         }
  178.         // 将size-1处的元素置为null，让垃圾回收器进行自动回收
  179.         elements[--size] = null;
  180.         return old;
  181.     }
  183.     /**
  184.      * 查看元素的位置
  185.      */
  186.     @Override
  187.     public int indexOf(E element) {
  188.         if (element == null) { // 1
  189.             for (int i = 0; i < size; i++) {
  190.                 if (elements[i] == null)
  191.                     return i;
  192.             }
  193.         } else {
  194.             // 遍历元素数组里面的所有值
  195.             for (int i = 0; i < size; i++) {
  196.                 // 如果该元素值和查询元素值相等
  197.                 if (elements[i] == element) {
  198.                     // 返回该元素索引
  199.                     return i;
  200.                 }
  201.             }
  202.         }
  203.         // 否则，返回 -1
  204.         return ELEMENT_NOT_FOUND;
  205.     }
  207.     /**
  208.      * 清除所有元素
  209.      */
  210.     @Override
  211.     public void clear() {
  212.         for (int i = 0; i < size; i++) {
  213.             elements[i] = null;
  214.         }
  215.         // 不清空数组，保留数组的内存，方便下次添加使用，避免重新创建数组，减少栈堆消耗
  216.         size = 0;
  217.     }
  219.     @Override
  220.     public String toString() {
  221.         // 打印格式：[100,50,101]
  222.         StringBuilder builder = new StringBuilder();
  223.         builder.append("size = ").append(size).append(", body = [");
  224.         for (int i = 0; i < size; i++) {
  225.             if (i != 0) {
  226.                 builder.append(", ");
  227.             }
  228.             builder.append(elements[i]);
  229.         }
  230.         builder.append("]");
  231.         return builder.toString();
  232.     }
  234.     private void outOfBounds(int index) {
  235.         throw new IndexOutOfBoundsException("Index:" + index + ", Size:" + size);
  236.     }
  238.     private void rangeCheck(int index) {
  239.         if (index < 0 || index >= size) {
  240.             outOfBounds(index);
  241.         }
  242.     }
  244.     private void rangeCheckForAdd(int index) {
  245.         if (index < 0 || index > size) {
  246.             outOfBounds(index);
  247.         }
  248.     }
  249. }

测试：

  1. public class Main {
  3.     public static void main(String[] args) {
  4.         ArrayList<Object> list  = new MyArrayList<>();
  5.         // 添加元素11
  6.         list.add(11);
  7.         list.add(100);
  8.         list.add(11);
  9.         // 将22添加到下标0的元素
  10. //        list.add(0,22);
  11.         System.out.println(list);
  12.         // 删除下标为1的元素
  13.         list.remove(1);
  14.         System.out.println(list);
  15.     }
  17. }

结果：

  1. size = 3, body = [11, 100, 11]
  2. size = 2, body = [11, 11]