基于数组实现顺序存储的线性表

package com.test.myarraylist;

import java.util.Arrays;

/**

 * 基于数组实现线性表

 * 

 * @author Wangjie

 * @version 1.0

 * @param <T>

 */

public class MyArrayList <T>{
private int DEFAULT_SIZE = 16 ;
//保存数组的长度
private int capacity ;
//保存当前线性表的长度，即元素的数量
private int size ;
//定义用来保存线性表元素的数组
private Object[] elementData;

/**
* 构造器
* 以默认的数组长度创建空的顺序线性表
*/
public MyArrayList(){
elementData = new Object[DEFAULT_SIZE];
capacity = DEFAULT_SIZE ;
System.out.println("无参构造函数执行");
}
/**
* 构造器
* 以一个元素初始化顺序线性表
* @param element 指定线性表中的第一个元素
*/
public MyArrayList(T element){
//调用无参构造函数进行创建数组
this();
elementData[0] = element ;
size++;
}
/**
* 以指定的长度和第一个元素初始化
* @param element 第一个元素
* @param initSize
指定线性表的长度
*/
public MyArrayList(T element , int initSize){
capacity = 1;
while(capacity<initSize){
capacity<<=1;
}
elementData = new Object[capacity];
elementData[0] = element ;
size++;
}
/**
* 获取线性表的大小
* @return
线性表的长度即元素的数量
*/
public int length(){
return size;
}
/**
* 获取指定索引处的元素
* @param i
指定索引
* @return
返回指定索引出的数值
*/
public T get(int i){
if(i<0||i>size-1){
throw new IndexOutOfBoundsException("线性表索引越界");
}
return (T) elementData[i];
}
/**
* 获取指定元素的索引
* @param element
指定元素
* @return
返回匹配的索引值
*/
public int locate(T element){
for(int i=0;i<size;i++){
if(elementData[i]==element){
return i;
}
}
return -1;
}
/**
* 在指定位置插入一个元素
* @param element
插入的元素
* @param i
指定的位置
*/
public void insert(T element,int index){
if(index<0||index>size){
throw new IndexOutOfBoundsException("线性表索引越界");
}
//利用数组复制函数将数组从index位置往后平移一个
System.arraycopy(elementData, index, elementData, index+1, size-index);
elementData[index]=element;
size++;
}

/**
* 检查数组的长度是否足以存储所有的元素，如果不够将进行扩展
* @param minCapacity 当前所需要的数组的最小长度
*/
private void ensureCapacity(int minCapacity){
if(minCapacity>capacity){
//一直循环，不断的将数组的长度*2，知道满足capacity大于minCapacity
//这是一个保险的做法，但是在此线性表的视线中，没有实现一次添加多个元素的情况，也就是说，即使存在元素唱过数组长度的情况，也只能每次超过一位，因为这个循环在此处存在意义并不大

// while(minCapacity>capacity){

// capacity<<=1;

// }
//因此此处我将循环注释掉
capacity<<=1;
elementData=Arrays.copyOf(elementData, capacity);
}
}
/**
* 在元素的开始处添加一个元素
* @param element
待添加的元素
*/
public void add(T element){
insert(element, size);
}
/**
* 删除指定位置的元素
* @param index 索引
* @return 返回删除的元素
*/
public T delete(int index){
if(index<0||index>size-1){
throw new IndexOutOfBoundsException("线性表索引越界");
}
T _oldElement=(T)elementData[index];
int _numMoved=size-index-1;
//排除删除的是最后一个元素的情况不用做元素的平移
if(_numMoved>0){
System.arraycopy(elementData, index+1, elementData, index , _numMoved);
}
//现将原本的最后一个元素清空，然后再把size减1
elementData[--size]=null;
return _oldElement;
}
/**
* 删除线性表的最后一个元素
* @return
返回线性表的最后一个元素
*/
public T remove(){
return delete(size-1);
}
/**
* 获取线性表是否为空
* @return
返回布尔值
*/
public boolean empty(){
return size==0;
}
/**
* 清空线性表
*/
public void clear(){
//将底层数组元素所有的元素赋值为NULL
Arrays.fill(elementData, null);
size=0;
}
public String toString(){
if(size==0){
return "[]";
}
else{
StringBuffer _stringBuffer=new StringBuffer("[");
for(int i=0;i<size;i++){
_stringBuffer.append(elementData[i].toString()+",");
}
int len =_stringBuffer.length();
return _stringBuffer.delete(len-2,len).append("]").toString();
}
}

}