用java实现动态的数组结构

增

add （int index，T t）：在指定角标添加元素
• addFirst （T t）：在开头添加元素
• addLast（T t）：在末尾添加元素

删

delete(int index)：删除指定角标的元素
• delFirst（）：删除数组中角标位0的元素
• remove（）：删除数组中最后一个元素

改

set（int index,）：删除数组中角标位0的元素
• replace(T t,newT newt) :使用newT来替换数组中所有的t（感觉太耗内存，没有实现）

查

get（int index) ： 获得指定角标位置的元素
• find（T t）：返回第一个存放指定元素的角标

当然除了这些功能，还复写了equals方法，hashcode方法。缺少一个toString方法的实现。

内部维护了一个自增数组，可以在数组容量满的时候，增加一倍，防止数组溢出，这样就不会出现数组容量不够的情况了。

package com.it.data;

public class Array<T> {
//内部维护的私有数组
private T[] data;
//定义现有大小
private int size;

public int getSize(){
return size;
}

public int getCapacity(){
return data.length;
}

/**
* 构造方法，传入容量即可。
* @param capacity
*/
public Array(int capacity){
data =(T[]) new Object[capacity];
size = 0;
}

/**
* 空参构造方法，默认生成数组容量为16的数组
*/
public Array(){
this(16);
}

/**
* 直接传入数组的构造方法
* @param arr
*/
public Array(T[] arr){
data = arr;
}

/**
* 查看数组是否为空
* @return
*/
public  boolean isEmpty(){
return size==0;
}

/**
* 在数组末尾添加一个元素
* @param t
* @throws Exception
*/
public void addLast(T t){
add(size,t);
}

/**
* 在数组开始处添加一个元素
* @param t
* @throws Exception
*/
public void addFirst(T t){
add(0,t);
}

/**
* @Description: 根据指定角标来添加一个元素
* @Param: [index, t]
* @return: void
*/
public void add(int index,T t){
if(index>size || index<0)
throw new IllegalArgumentException("插入角标违法，请检查后再输入");

if (this.getCapacity() == this.getSize()) {
capactyInc(this.getCapacity()*2);
}
for (int i = index; i < size ; i++) {
data[i+1]  = data[i];
}
data[index] = t;
size++;
}

/**
* @Description: 根据角标删除元素
* @Param: [index]
* @return: T
*/
public T delete(int index){
if(index>= size|| index<0) {
throw new IllegalArgumentException("角标位置不存在元素");
}
T t = data[index];
for (int i = index; i < size ; i++) {
data[i] = data[i+1];
}
size--;
return  t;
}

/**
* @Description: 删除第一个元素
* @Param: []
* @return: T
*/
public T delFirst() {
return delete(0);
}

/**
* 移除最后一个元素,remove方法默认为移除最后的一个元素
* @return
* @throws Exception
*/
public T remove(){
return  delete(size-1);
}

/**
* 修改相应角标的元素
* @param index
* @param t
* @return
* @throws Exception
*/
public T set(int index,T t){
if(index>= size|| index<0) {
throw new IllegalArgumentException("角标位置不存在元素");
}
T temp = data[index];
data[index] = t;
return temp;
}

/**
* 根据角标来查询元素
* @param index
* @return
* @throws Exception
*/
public T get(int index){
if(index>= size|| index<0) {
throw new IllegalArgumentException("角标位置不存在元素");
}
return  data[index];
}

/**
* 截取一个相应的集合
* @param index
* @param length
* @return
* @throws Exception
*/
public T[] getArray(int index,int length){
if(index>= size|| index<0) {
throw new IllegalArgumentException("角标位置不存在元素");
}
if (length<0 || index+length>=size){
throw  new IllegalArgumentException("需要的长度不存在，请重新确认长度");
}
T[] temp = (T[]) new Object[length];
for (int i = 0; i < length; i++,index++) {
temp[i] = data[index];
}
return  temp;
}

/**
* @
*/
public int getIndex(T t){
//本想使用forEach循环,但包含结果也需要返回角标，所以使用for循环才能拿到他的角标
for (int i = 0; i < size ; i++) {
if(data[i].equals(t)){
return  i;
}
}
return -1;
}

/**
* 判断是否包含某个元素
* @param t
* @return
*/
public boolean contains(T t){
for (int i = 0; i < size; i++) {
if (data[i].equals(t)){
return true;
}
}
return  false;
}

/**
* 在输入容量不够的情况下，自增容量
* @param capacity
*/
private void capactyInc(int capacity){
T[] newData = (T[])new Object[capacity];
for (int i = 0; i < size; i++) {
newData[i] = data[i];
}
data = newData;
}

@Override
public int hashCode() {
return super.hashCode();
}

@Override
public boolean equals(Object obj) {
if(obj instanceof Array){
Array arr = (Array) obj;
for (int i = 0; i < arr.getSize(); i++) {
try {
if (data[i].equals(arr.get(i)))
continue;
return false;
} catch (Exception e) {
e.printStackTrace();
}
}
return true;
}
return false;
}
}