• public class Array<E> {private E[] data;  //设置为private，不希望用户从外部直接获取这些信息，防止用户篡改数据private int size;//构造函数，传入数组的容量capacity构造Arraypublic Array(int capacity) {data = (E[]) new Object[capacity];size = 0;}//无参数构造函数，默认数组容量capacity=10public Array() {this(10);    //这里的capacity是IDE自动添加的提示信息，实际不存在
      }//获取数组中的元素个数public int getSize() {return size;}//获取数组的容量public int getCapacity() {return data.length;}//判断数组是否为空public boolean isEmpty() {return size == 0;}//向数组末尾添加一个新元素epublic void addLast(E e) {add(size, e);}//向数组开头添加一个新元素epublic void addFirst(E e) {add(0, e);}//在index位置插入一个新元素epublic void add(int index, E e) {if (size == data.length) {throw new IllegalArgumentException("Add failed. Array is full.");}if (index < 0 || index > size) {throw new IllegalArgumentException("Add failed. Require index >= 0 and index <= size");}for (int i = size - 1; i >= index; i--) {data[i + 1] = data[i];}data[index] = e;size++;}//获取index位置的元素public E get(int index) {if (index < 0 || index >= size) {throw new IllegalArgumentException("Get failed. Index is illegal.");}return data[index];}//修改index位置的元素为epublic void set(int index, E e) {if (index < 0 || index >= size) {throw new IllegalArgumentException("Set failed. Index is illegal.");}data[index] = e;}//查找数组中是否存在元素epublic boolean contains(E e) {for (int i = 0; i < size; i++) {if (data[i].equals(e)) {return true;}}return false;}//查看数组中元素e的索引，若找不到元素e，返回-1public int find(E e) {for (int i = 0; i < size; i++) {if (data[i].equals(e)) {return i;}}return -1;}//删除掉index位置的元素，并且返回删除的元素public E remove(int index) {if (index < 0 || index >= size) {throw new IllegalArgumentException("Remove failed. Index is illegal.");}E ret = data[index];for (int i = index + 1; i < size; i++) {data[i - 1] = data[i];}size--;   //data[size]会指向一个类对象，这部分空间不会被释放loitering objectsdata[size] = null;return ret;}//删除掉数组开头的元素，并返回删除的元素public E removeFirst() {return remove(0);}//删除掉数组末尾的元素，并返回删除的元素public E removeLast() {return remove(size - 1);}//如果数组中有元素e，那么将其删除，否则什么也不做public void removeElement(E e) {int index = find(e);if (index != -1) {remove(index);}}@Overridepublic String toString() {    //覆盖父类的toString方法
  StringBuilder res = new StringBuilder();res.append(String.format("Array: size=%d, capacity=%d\n", size, data.length));res.append('[');for (int i = 0; i < size; i++) {res.append(data[i]);if (i != size - 1) {res.append(", ");}}res.append(']');return res.toString();}
  }

8.. 再次在main方法中实例化我们的自定义数组，进行测试：

• public class Main {public static void main(String[] args) {Array<Integer> arr = new Array<>(20);for (int i = 0; i < 10; i++) {arr.addLast(i);}System.out.println(arr);arr.add(1, 100);System.out.println(arr);arr.addFirst(-1);System.out.println(arr);arr.remove(2);System.out.println(arr);arr.removeElement(4);System.out.println(arr);arr.removeFirst();System.out.println(arr);arr.removeLast();System.out.println(arr);}
  }

• 输出结果如下：

• Array: size=10, capacity=20
  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  Array: size=11, capacity=20
  [0, 100, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  Array: size=12, capacity=20
  [-1, 0, 100, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  Array: size=11, capacity=20
  [-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  Array: size=10, capacity=20
  [-1, 0, 1, 2, 3, 5, 6, 7, 8, 9]
  Array: size=9, capacity=20
  [0, 1, 2, 3, 5, 6, 7, 8, 9]
  Array: size=8, capacity=20
  [0, 1, 2, 3, 5, 6, 7, 8]

9.. 测试让自定义数组去承载对象

• public class Student {private String name;private int score;public Student(String studetName, int studentScore) {name = studetName;score = studentScore;}@Overridepublic String toString() {return String.format("Student(name: %s, score: %d)", name, score);}public static void main(String[] args) {Array<Student> arr = new Array<>();arr.addLast(new Student("XueZou", 98));arr.addLast(new Student("Guiche", 100));arr.addLast(new Student("QUiShui", 99));System.out.println(arr);}
  }

• 输出结果如下：

• Array: size=3, capacity=10
  [Student(name: XueZou, score: 98), Student(name: Guiche, score: 100), Student(name: QUiShui, score: 99)]

• 修改add方法的业务逻辑，使自定义数组支持扩容

• //在index位置插入一个新元素e
  public void add(int index, E e) {if (index < 0 || index > size) {throw new IllegalArgumentException("Add failed. Require index >= 0 and index <= size");}if (size == data.length) {resize(2 * size); //扩大为原容量的2倍
      }for (int i = size - 1; i >= index; i--) {data[i + 1] = data[i];}data[index] = e;size++;
  }

• 我们需要实现resize方法，业务逻辑如下：

• private void resize(int newCapacity) {E[] newData = (E[]) new Object[newCapacity];for (int i = 0; i < size; i++) {newData[i] = data[i];}data = newData;
  }

• 实现扩容后，进行测试：

• public static void main(String[] args) {Array<Integer> arr = new Array<>();for (int i = 0; i < 10; i++) {arr.addLast(i);}System.out.println(arr);arr.add(1, 100);System.out.println(arr);arr.addFirst(-1);System.out.println(arr);
  }

• 输出效果如下：

• Array: size=10, capacity=10
  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  Array: size=11, capacity=20
  [0, 100, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  Array: size=12, capacity=20
  [-1, 0, 100, 1, 2, 3, 4, 5, 6, 7, 8, 9]

• 修改remove方法，使数组中的元素减少到一定程度时，自动缩小数组容量

• //删除掉index位置的元素，并且返回删除的元素
  public E remove(int index) {if (index < 0 || index >= size) {throw new IllegalArgumentException("Remove failed. Index is illegal.");}E ret = data[index];for (int i = index + 1; i < size; i++) {data[i - 1] = data[i];}size--;   //data[size]会指向一个类对象，这部分空间不会被释放loitering objectsdata[size] = null;if (size == data.length / 2) {resize(data.length / 2);  //被利用的空间等于总空间的一半时，将数组容量减少一半
      }return ret;
  }

• 实现自动降低容量后，进行测试：

• public static void main(String[] args) {Array<Integer> arr = new Array<>();for (int i = 0; i < 10; i++) {arr.addLast(i);}System.out.println(arr);arr.add(1, 100);System.out.println(arr);arr.addFirst(-1);System.out.println(arr);arr.remove(2);System.out.println(arr);arr.removeElement(4);System.out.println(arr);arr.removeFirst();System.out.println(arr);
  }

• 输出效果如下：

• Array: size=10, capacity=10
  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  Array: size=11, capacity=20
  [0, 100, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  Array: size=12, capacity=20
  [-1, 0, 100, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  Array: size=11, capacity=20
  [-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  Array: size=10, capacity=10
  [-1, 0, 1, 2, 3, 5, 6, 7, 8, 9]
  Array: size=9, capacity=10
  [0, 1, 2, 3, 5, 6, 7, 8, 9]

• O(1), O(n), O(lgn), O(nlgn), O(n^2)
• 大O描述的是算法的运行时间和输入数据之间的关系
• 通常我们会说下面的这段代码的算法是O(n)的，n在这里简单理解为nums中的元素个数，O(n)是说下面这段代码的运行效率，与nums中的元素个数n是呈线性关系的，线性关系体现在n是一次方。

• public static int sum(int[] nums) {int sum = 0;for (int num: nums) {sum += num;return sum;}

• 按照这个思路我们对上面所实现的方法，挨个分析一下它们的算法的时间复杂度：添加操作中addLast(e)方法的时间复杂度是O(1)，这表示我们的算法所消耗的时间与我们数据的规模没有关系，这里所指的数据规模是我们数组中的元素个数；addFirst(e)方法的时间复杂度是O(n)，因为每个元素都需要向后移动一位；add(index, e)方法的时间复杂度与index的具体取值相关，它的时间复杂度也是O(n)；综合来看，添加操作是一个O(n)级别的算法。
• 删除操作中，removeLast(e)方法的时间复杂度是O(1)；removeFirst(e)的时间复杂度是O(n)；remove(index, e)的时间复杂度也是O(n)；综合来看，删除操作的时间复杂度也是O(n)。
• 修改操作set(index, e)的时间复杂度是O(1)，这是数组的最大优势，专业术语称为"支持随机访问"。
• 查询操作中，get(index)方法的时间复杂度是O(1)；find(e)方法和contains(e)方法的时间复杂度都是O(n)。

• 增：时间复杂度O(n);
• 删：时间复杂度O(n);
• 改：已知索引O(1)，未知索引O(n);
• 查：已知索引O(1)，未知索引O(n);
• 因此，索引具有语义时，选择数组是非常好的，我们可以通过索引轻松检索数据中的内容。

• 对于添加操作，如果我们只使用addLast方法，那么它的时间复杂度本来应该是O(1)，但是，由于存在resize方法，而resize方法的时间复杂度是O(n)，所以addLast方法的时间复杂度就不是O(1)了，但是它的均摊复杂度是O(1);
• 类似的对于删除操作，如果只使用removeLast方法，那么它的均摊复杂度也是O(1);

• 复杂度震荡，是指我们在数组容量的临界位置交替进行添加和删除操作，这会导致数组不断执行扩容和缩容操作，而扩容和缩容的时间复杂度都是O(n)，出现这种问题的原因在于，我们执行removeLast方法后，resize得有点着急(Eager)，解决方案是使用更加懒惰的策略(Lazy)，简单理解就是，当数组占用量刚好减到1/2时，不着急缩容，等减到1/4时，再触发缩容，只缩1/2。
• 我们需要稍微改动一下remove方法，如下所示：

• public E remove(int index) {if (index < 0 || index >= size) {throw new IllegalArgumentException("Remove failed. Index is illegal.");}E ret = data[index];for (int i = index + 1; i < size; i++) {data[i - 1] = data[i];}size--;   //data[size]会指向一个类对象，这部分空间不会被释放loitering objectsdata[size] = null;if (size == data.length / 4 && data.length / 2 != 0) {       //改动在这里resize(data.length / 2);  //被利用的空间等于总空间的一半时，将数组容量减少一半
      }return ret;
  }