基于链表结构的10进制数组集合

离散数组，长度不受限制；
每个数组的长度为12；上层数组最多引用10个下层数组，最底层数组记录数据，后两位分别记录当前数组记录的非空元素个数以及上位数组的引用，元素为空时，卸载相关数组，节省内存；
相比于ArrayList，不需要扩容，不必复制数组，可以指定元素存放在数组的位置，但每次调用都需要大量计算；
代码实现（代码中长度用long类型接收，计算时长度受限，最大长度为99999999999999999，可以用字符串接收长度，利用字符的相关方法取位计算，数组的最大长度将不受限制，当然，数组所存的非空元素的总量还受物理内存的约束）：

public class InfiniteArr {
 //初始化集合
    private Object[] sta=new Object[12];
   //初始化实际集合长度
    private long len=10;
    public InfiniteArr() {
     sta[10]=2;
    }
    public Object get(long num) {
     Object[] now=sta;
    //输出数组对象
    if(num>=len) {
     return null;
     } 
     else {
     long num0=num;
     long flag=0;
     long len0=len;
     flag=num0*10/len;
    num0=num0*10%len;  
     for(;len0>10;) { 
        len0=len0/10;
         if(now[(int) flag]!=null) {
        now=(Object[]) now[(int) flag];
         }
         else return null;
        flag=num0*10/len;
       num0=num0*10%len;  
        }   
       return now[(int) flag];
      }
    }   
    public void set(long num,Object neo) {
     if(neo==null) {
           if(num>len) return;
            else {
              Object[] now=sta;
              long num0=num;
                long flag=0;
                long len0=len;
                flag=num0*10/len;
               num0=num0*10%len;  
                for(;len0>10;) { 
                   len0=len0/10;
                    if(now[(int) flag]!=null) {
                   now=(Object[]) now[(int) flag];
                    }
                    else {
                   return ;
                    }
                   flag=num0*10/len;
                  num0=num0*10%len;  
                } 
               now[(int)flag]=null;
             now[10]=(int)now[10]-1;
            //向上卸载数组
                 num0=num;
              for(;(int)now[10]==0;) {
               flag=num0%10;
               num0=num0/10;
               now=(Object[]) now[11];
               now[(int)flag]=null;
               now[10]=(int)now[10]-1;
              }
            //向下卸载数组
              for(;(int)sta[10]==1;) {
                sta=(Object[]) sta[0];
                sta[11]=null;
                len=len/10;
                }
     }
    }
     else {
         long excess=num/len;
         long num0=num;
        //向上构建
        Object[] now=sta;
         for(;excess>0;) {
          //减少剩余次数
          excess=excess/10;
          //创建搭载数组
          Object[] now1=new Object[12];
          //标记搭载数组
          sta[11]=now1;
          //搭载数组
          now1[0]=sta;
          //数组上移
          sta=now1;
          //改变搭载个数
          sta[10]=1;
          //改变集合长度
          len=len*10;
         }
         now=sta;
        //向下添加，构建  
             long flag=num0*10/len;
            num0=num0*10%len;
            long len0=len;
         for(;len0>10;) { 
         len0=len0/10;
             if(now[(int) flag]!=null) now=(Object[]) now[(int) flag];  
             else {
            //搭载数组个数加一
            now[10]=(int)now[10]+1; 
            //创建搭载数组
            Object[] now1=new Object[12];
            //初始化创建数组的搭载个数
            now1[10]=0;
            //搭载数组
           now[(int) flag]=now1;
           //标记搭载数组
           now1[11]=now;
           //数组下移
           now=now1;
             }
            flag=num0*10/len;
           num0=num0*10%len;
         }
         now[(int)flag]=neo;
         now[10]=(int)now[10]+1;
     }
 }
}