java数组伸缩_Java数据结构与算法--运用泛型编程实现自定义可动态伸缩的数组类...

使用java，运用泛型编程，实现一个自定义数组类，此类可以做到动态扩展数组长度和动态释放数组空间，同时可以支持各种数据类型(泛型)

自定义类的一个好处是可以根据需求任意去扩充方法，这里开发了一些数组中常见的操作方法

public class Array {

private E[] data;

private int size;

/**

* 构造函数，传入数组的容量capacity构造Array

* @param capacity

*/

public Array(int capacity)

{

this.data=(E[]) new Object[capacity];

this.size=0;

}

/**

* 无参数的构造函数，默认初始化一个长度为10的空数组

*/

public Array()

{

this(10);

}

/**

* 获取数组中元素的个数

* @return

*/

public int getSize()

{

return this.size;

}

/**

* 获取数组的容量

* @return

*/

public int getCapacity()

{

return this.data.length;

}

/**

* 返回数组是否为空

* @return

*/

public boolean isEmpty()

{

return this.size==0;

}

/**

* 向数组的末尾增加一个元素

* @param elem

*/

public void addLast(E elem)

{

this.insert(this.size,elem);

}

/**

* 向数组的起始位置增加一个元素

* @param elem

*/

public void addFirst(E elem)

{

this.insert(0,elem);

}

/**

* 在数组指定index插入元素

* @param index

* @param elem

*/

public void insert(int index,E elem)

{

if(index<0||index>this.size)

{

throw new IllegalArgumentException("insert failed.Required index >=0 and index<=size.");

}

if(this.size==this.data.length)

{

this.resize(2*this.data.length);

}

for(int i=this.size-1;i>=index;i--)

{

this.data[i+1]=this.data[i];

}

this.data[index]=elem;

this.size++;

}

private void resize(int newCapacity)

{

E[] newData=(E[]) new Object[newCapacity];

for(int i=0;i

{

newData[i]=this.data[i];

}

this.data=newData;

}

/**

* 根据索引index获取index处的元素的值

* @param index

* @return

*/

public E get(int index)

{

if(index<0 || index>=this.size)

{

throw new IllegalArgumentException("insert failed.Required index >=0 and index<=size.");

}

return this.data[index];

}

/**

* 对索引index处的值进行设置

* @param index

* @param elem

*/

public void set(int index,E elem)

{

if(index<0 || index>=this.size)

{

throw new IllegalArgumentException("insert failed.Required index >=0 and index<=size.");

}

this.data[index]=elem;

}

/**

* 删除数组中第一个元素

* @return

*/

public E removeFirst()

{

return remove(0);

}

/**

* 删除数组最后一个元素

* @return

*/

public E removeLast()

{

return remove(this.size);

}

/**

* 根据指定的值删除数组中的元素，数组中若存在多个值，则删除第一个值

* @param elem

*/

public void removeElement(E elem)

{

int index=this.indexOf(elem);

if(index!=-1)

{

this.remove(index);

}

}

/**

* 删除指定index索引处的元素

* @param index

* @return

*/

public E remove(int index)

{

if(index<0 || index>=this.size)

{

throw new IllegalArgumentException("insert failed.Required index >=0 and index<=size.");

}

E ret=this.data[index];

for(int i=index;i

{

this.data[i]=this.data[i+1];

}

this.size--;

this.data[this.size]=null;

// 当数组中元素的个数为数组长度的1/4时，释放1/2的数组空间

// 判断数组中元素个数为数组长度的1/4,而不是1/2，是为了解决和insert方法动态扩展数组时产生复杂度震荡的问题

if(this.size==this.data.length/4 && this.data.length/2 !=0 )

{

this.resize(this.data.length/2);

}

return ret;

}

/**

* 判断数组中是否存在指定元素值，若存在返回true，否则返回false

* @param elem

* @return

*/

public boolean contains(E elem)

{

for(int i=0;i

{

if(this.data[i].equals(elem))

{

return true;

}

}

return false;

}

/**

* 获取元素在数组中的索引，若不存在，则返回-1，若存在多个，则返回第一个元素的索引值

* @param elem

* @return

*/

public int indexOf(E elem)

{

for(int i=0;i

{

if(this.data[i]==elem)

{

return i;

}

}

return -1;

}

@Override

public String toString()

{

StringBuilder res=new StringBuilder();

res.append(String.format("Array:size= %d , capacity = %d\n",this.size,this.data.length));

res.append("[");

for(int i=0;i

{

res.append(this.data[i]);

if(i != this.size-1)

{

res.append(",");

}

}

res.append("]");

return res.toString();

}

}