日常学习随笔-自定义了一个MyArrayListDefin集合（数组扩容+迭代器+JDK1.8新方法+详细说明）

一、自定义了一个ArrayList的模拟集合（源码+详细说明）

　　前段时间分析了下ArrayList集合的源码，总觉得如果不自己定义一个的话，好像缺了点什么，所以有了如下的代码。

　代码可以说是逐行注释了，所以就不做过多的分析了。

类结构展示图：

自定义集合：MyArrayListDefin.java

 package com.xfwl.algorithmAnalysis.linklsit;

 import java.util.Arrays;
 import java.util.Iterator;
 import java.util.NoSuchElementException;
 import java.util.Objects;
 import java.util.Spliterator;
 import java.util.Spliterators;
 import java.util.function.Consumer;

 /**
  * 学习整理-模拟一个ArrayList（数组容器）
  * @function  自定义ArrayList
  * @author 小风微凉
  * @time  2018-5-13 上午7:25:28
  */
 public class MyArrayListDefin<T> implements Iterable<T>{
     /**
      * 定义一个默认扩展容量
      */
     private static final int DEFAULT_CAPACITY=10;
     /**
      * 当前集合的容量
      */
     private int intSize;
     /**
      * 当前集合容器
      */
     private T[] theItems;
     /**
      * 构造器
      */
     public MyArrayListDefin(){
         //重置集合初始数据

         this.clear();
     }
     /**
      * 清除容器中数据
      */
     private void clear(){
         //设置初始化数据
         this.intSize=0;
         //重置数组容器:默认容量设置为初始值：10
         this.ensureCapacity(DEFAULT_CAPACITY);
     }
     /**
      * 设置容器大小
      * @param newCapacity 新容量大小
      * 说明：这里参考ArrayList源码中的一套扩展规则">>"
      */
     public void ensureCapacity(int newCapacity){
         //大小范围检查
         if(newCapacity<=this.intSize){//不超过了当前容器的容量大小
             return;//则不需要扩展容器容量
         }
         //数组初始值判断
         if(this.theItems==null){
             theItems=(T[]) new Object[newCapacity];
             return;//第一次初始化进来
         }
         //需要扩展容器容量
         T[] newItems=(T[]) Arrays.copyOf(this.theItems, newCapacity,this.theItems.getClass());
         this.theItems=newItems;
         //分析说明下：
         /**
          * Array.copyOf();内部封装了
          * System.arraycopy(this.theItems, 0, newItems, 0, this.theItems.length);这个方法
          */
         //效果等效于=》：System.arraycopy(this.theItems, 0, newItems, 0, this.theItems.length);
     }
     /**
      * 返回容器容量大小
      * @return
      */
     public int size(){
         return this.intSize;
     }
     /**
      * 判断容器是否为空
      * @return
      */
     public boolean isEmpty(){
         return this.size()==0;
     }
     /**
      * 按照容器现有的数据所在的容量，瘦身容器容量
      */
     public void trimCapacity(){
         this.ensureCapacity(this.size());
     }
     /**
      * 获取指定位置的数据
      * @param index    位置索引值
      * @return
      */
     public T get(int index){
         //范围合法性检查
         if(index<0 ||index>=size()){
             throw new ArrayIndexOutOfBoundsException("获取的位置不合法！");
         }
         //验证通过
         return this.theItems[index];
     }
     /**
      * 给容器中的指定位置设置数据
      * @param index 位置索引值
      * @param newData    数据
      */
     public void set(int index,T newData){
         //位置合法性判断
         if(index<0 || index>size()){
             throw new ArrayIndexOutOfBoundsException("设置的位置不合法！");
         }
         //验证通过
         T oldData=this.theItems[index];
         System.out.println("集合中索引值="+index+"，的数据【"+oldData+"】即将被重置为：【"+newData+"】");
         this.theItems[index]=newData;
     }
     /**
      * 添加一个数据到集合中(追加到末尾)
      * @param newData  数据
      * @return true 添加成功   false 添加失败
      */
     public boolean add(T newData){
         this.set(this.size(), newData);
         this.intSize++;
         return true;
     }
     /**
      * 在指定位置添加一个新数据
      * @param index    指定的位置索引值
      * @param newData    新的数据
      */
     public void add(int index,T newData){
         //位置合法性检查
         if(this.theItems.length==this.size()){//当前数组长度刚好被占满了，那么就急需要扩容
             //设置扩容规则：这里参考ArrayList源码中的一套扩展规则">>1"
             int newCapacity=this.size()+this.size()>>1;//扩展量：取当前容量的一半，且向下取整
             this.ensureCapacity(newCapacity);
         }
         //继续添加新数据，同时后续位置的数据向后挪移一位
         /**
          * System.arraycopy(...)
          * 参数说明：
          *     第一位：复制的源数组
          *  第二位：从index的索引值处开始
          *  第三位：目标数组
          *  第四位：复制的数据目标数组的第（index+1)索引值处开始存放
          *  第五位：总共需要复制（this.size()-index)个数据：有效数据大小-索引值前的数据个数（包含数值处的数据）
          */
         System.arraycopy(this.theItems, index, this.theItems, index+1, this.size()-index);
         //开始设置新数据
         this.theItems[index]=newData;
         //当前集合容器有效数据大小+1
         this.intSize++;
     }
     /**
      * 从集合数组中移除指定位置的数据
      * @param index    数据的位置索引值
      */
     public void remove(int index){
         //位置的合法性检查
         if(index<0 || index>this.size()){
             throw new ArrayIndexOutOfBoundsException("要移除的数据的位置索引值不合法！");
         }
         //检查通过:要移除的位置之后的数据前移一位
         System.arraycopy(this.theItems, index+1, this.theItems, index, this.size()-index-1);
         //末尾的数据需要置空
         this.theItems[this.size()-1]=null;
         //当前有效数据大小-1
         this.intSize--;
     }
     /**
      * 从集合中移除指定的数据
      * @param data    数据
      */
     public void remove(T data){
         //需要找到这个数据的所在位置
         int index=0;
         for(T t:this.theItems){
             if(data==t){
                 remove(index);
                 break;
             }
             index++;
         }
     }
     /**
      * 获取迭代器的方法
      * --用于拿到自定义的迭代器
      */
     @Override
     public Iterator<T> iterator() {
         return new ArrayListIterator();
     }
     /**
      * JDK1.8新增的方法
      * 循环处理集合中的数据，
      * 此处的规则是：把当前集合的数据容器中的每一条数据，交给action来处理
      */
     @Override
     public void forEach(Consumer<? super T> action) {
          Objects.requireNonNull(action);

          for (T t : this.theItems) {
             action.accept(t);
          }
     }
     /**
      * 打印当前集合的基本信息
      */
     @Override
     public String toString() {
         return "集合总容量："+this.theItems.length+",集合当前使用的容量："+this.intSize+",下一次容量扩展值："+(this.theItems.length>>1);
     }
     /**
      * JDK1.8新增的方法
      *    splitable iterator可分割迭代器）接口是Java为了并行遍历数据源中的元素而设计的迭代器，
      * 这个可以类比最早Java提供的顺序遍历迭代器Iterator，但一个是顺序遍历，一个是并行遍历。
      */
     @Override
     public Spliterator<T> spliterator() {
         return Spliterators.spliteratorUnknownSize(iterator(), 0);
     }
     /**
      * 内置一个迭代器
      * @function  可以在自定义的迭代器中，按照自己的方式实现功能
      *     这里说明一下：
      *         我们都知道：（1）数组的查询、修改    快于新增和删除，因为一般的删除和新增基本上都会牵涉到数据的后移或迁移，比较消费资源。
      *                   （2）单链表结构的查询和修改，则慢于新增和删除，因为一般的查询和修改，需要从头结点开始向下遍历，直到找到要查询的结点方可修改。而删除则不需要遍历。
      *                   （3）双链表结构的查询、修改、新增、删除则要快于单链表，因为双链表的结点中，包含了前驱结点和后驱结点的引用，双链表是环形结构。
      *         所以呀，这个迭代器的实现就至少可以有上面三种的实现方式，三种方式代表迭代器会用三种方式去处理集合的数据，其中就优劣势就需要仔细考量了！
      * 特别说明：下面的迭代器使用的是第一种：数组的方式，至于后面的2种方式，在之后的学习中，会慢慢研究。
      * @author 小风微凉
      * @time  2018-5-13 上午9:16:56
      * @param <T>
      */
     private class ArrayListIterator<T> implements Iterator<T>{
         /**
          * 当前迭代器，迭代的位置：默认值为0
          */
         private int currPos=0;
         /**
          * 判断是否有下一个数据
          */
         @Override
         public boolean hasNext() {
             return currPos<MyArrayListDefin.this.size();
         }
         /**
          * 拿到集合中的下一个数据
          */
         @Override
         public T next() {
             if(!hasNext()){
                 throw new NoSuchElementException("已经没有下一个数据了！");
             }
             return (T) MyArrayListDefin.this.theItems[currPos++];
         }
         /**
          * 使用迭代器移除集合中的当前迭代到的数据
          */
         @Override
         public void remove() {
             MyArrayListDefin.this.remove(--currPos);
         }
         /**
          * jdk1.8新增的方法
          * 针对性地处理下一个迭代数据
          * 此处定义的规则是：把当前迭代器要处理的下一个数据，交给action来处理
          */
         @Override
         public void forEachRemaining(Consumer<? super T> action) {
             action.accept(next());
         }
     }
 }

运行类：Test.java

 package com.xfwl.algorithmAnalysis.linklsit;
 import java.util.Arrays;
 import java.util.Iterator;
 import java.util.List;
 import java.util.function.Consumer;

 /**
  * 测试自定义集合：MyArrayListDefin
  * @function
  * @author 小风微凉
  * @time  2018-5-13 上午11:01:54
  */
 public class Test {
     public static void main(String[] args) {
         //拿到一个集合对象
         System.out.println("--------创建集合对象并添加数据-----------------");
         MyArrayListDefin<Object> arrList=new MyArrayListDefin<Object>();
         //添值
         arrList.add(1);
         arrList.add("String_2");
         arrList.add('3');
         arrList.add("小风微凉");
         System.out.println(arrList.toString());
         //开始迭代器遍历
         System.out.println("--------开始打印数据-----------------");
         Iterator<Object> it=arrList.iterator();
         for(;it.hasNext();){
             Object eachObj=it.next();
             System.out.println(eachObj);

         }
         System.out.println(arrList.toString());
         System.out.println("--------END-----------------");
         //指定位置修改一个数据
         arrList.set(0, "第一个位置的数据被修改");
         Iterator<Object> it2=arrList.iterator();
         System.out.println("--------开始打印数据-----------------");
         for(;it2.hasNext();){
             Object eachObj=it2.next();
             System.out.println(eachObj);

         }
         System.out.println(arrList.toString());
         System.out.println("--------END-----------------");
         //指定位置添加一个数据
         arrList.add(1, "第二个位置的数据被添加");
         Iterator<Object> it3=arrList.iterator();
         System.out.println("--------开始打印数据-----------------");
         for(;it3.hasNext();){
             Object eachObj=it3.next();
             System.out.println(eachObj);
         }
         System.out.println(arrList.toString());
         System.out.println("--------END-----------------");
         //删除一个指定位置的数据
         arrList.remove(1);
         Iterator<Object> it4=arrList.iterator();
         System.out.println("--------开始打印数据-----------------");
         for(;it4.hasNext();){
             Object eachObj=it4.next();
             System.out.println(eachObj);
         }
         System.out.println(arrList.toString());
         System.out.println("--------END-----------------");
         //删除一个数据
         arrList.remove("String_2");
         Iterator<Object> it5=arrList.iterator();
         System.out.println("--------开始打印数据-----------------");
         for(;it5.hasNext();){
             Object eachObj=it5.next();
             System.out.println(eachObj);
         }
         System.out.println(arrList.toString());
         System.out.println("--------END-----------------");
         //测试forEach()方法
         arrList.forEach(new Consumer1("集合中的forEach方法："));
         //测试迭代器中的Consumer1Consumer1方法
         Iterator<Object> it6=arrList.iterator();
         it6.forEachRemaining(new Consumer1("集合中迭代器的forEachRemaining方法："));

     }
     private static class Consumer1<T> implements Consumer<T>{
         private String info;
         public Consumer1(String info){
             this.info=info;
         }
         @Override
         public void accept(T t) {
             System.out.println(info+t);
         }
         @Override
         public Consumer andThen(Consumer after) {
             // TODO Auto-generated method stub
             return null;
         }

     }
 }

运行测试结果：（正常）

--------创建集合对象并添加数据-----------------
集合中索引值=0，的数据【null】即将被重置为：【1】
集合中索引值=1，的数据【null】即将被重置为：【String_2】
集合中索引值=2，的数据【null】即将被重置为：【3】
集合中索引值=3，的数据【null】即将被重置为：【小风微凉】
集合总容量：10,集合当前使用的容量：4,下一次容量扩展值：5
--------开始打印数据-----------------
1
String_2
3
小风微凉
集合总容量：10,集合当前使用的容量：4,下一次容量扩展值：5
--------END-----------------
集合中索引值=0，的数据【1】即将被重置为：【第一个位置的数据被修改】
--------开始打印数据-----------------
第一个位置的数据被修改
String_2
3
小风微凉
集合总容量：10,集合当前使用的容量：4,下一次容量扩展值：5
--------END-----------------
--------开始打印数据-----------------
第一个位置的数据被修改
第二个位置的数据被添加
String_2
3
小风微凉
集合总容量：10,集合当前使用的容量：5,下一次容量扩展值：5
--------END-----------------
--------开始打印数据-----------------
第一个位置的数据被修改
String_2
3
小风微凉
集合总容量：10,集合当前使用的容量：4,下一次容量扩展值：5
--------END-----------------
--------开始打印数据-----------------
第一个位置的数据被修改
3
小风微凉
集合总容量：10,集合当前使用的容量：3,下一次容量扩展值：5
--------END-----------------
集合中的forEach方法：第一个位置的数据被修改
集合中的forEach方法：3
集合中的forEach方法：小风微凉
集合中的forEach方法：null
集合中的forEach方法：null
集合中的forEach方法：null
集合中的forEach方法：null
集合中的forEach方法：null
集合中的forEach方法：null
集合中的forEach方法：null
集合中迭代器的forEachRemaining方法：第一个位置的数据被修改

总结：

　　上面这个自定义的（仿ArrayList）集合，还有不完善的地方，原本打算是把迭代器写成单链表，最好是双链表结构的，但是考虑现在是学习阶段，所以还是从最基础的方式学起，后续的LinkedList的学习和自定义在尝试使用单链表或多链表结构的迭代器。一步步来吧！