java数据结构之队列/泛型_JAVA_编程开发_程序员俱乐部

首先实现一个简单的自定义的队列其实比较简单，只要实现了队列的各种操作例如：
向队列中加入元素：public void add(String s);
修改队列指定位置的元素:public void modify(String s,int index);
向队列指定位置插入元素：public void insert(String s,int index);
获得队列的长度：public int  size();
删除队列指定位置的元素：public void delete(int index);
但是这种队列有个问题就是这只是针对String类型一种队列，这个队列只能装String字符串！因此如果采用这种机制我们就必须要定义很多的队列！
Java为了程序开发者的方便引入了泛型（Generic Type）机制，在定义泛型的时候并不指定数据类型，它允许程序员在使用的时候才指定类型！

/**
* 实现泛型借口的类;
* @author luliangy
*
*/
public class EArrList<E> implements EList<E>{

Object[] src=null;
//设置增长规模
private int InitSize=100;//初始规模
private int IncreseSize=10;//增长规模
private int size=0;//队列的规模

public EArrList(){
//在构造队列的时候就开辟制定的空间;
this.src=new Object[this.InitSize];
}
/**
* 重载构造函数
* @param IniSize
*/
public EArrList(int initSize){
this.InitSize=initSize;
this.src=new Object[this.InitSize];
}
/**
* 完整的构造器
* @param InitSize
* @param IncreseSize
*/
public EArrList(int InitSize,int IncreseSize){
this.IncreseSize=IncreseSize;
this.InitSize=InitSize;
this.src=new Object[this.InitSize];
}

/**
* 项队列中加入元素;
*/
public void add(E e){
this.size++;//数组长度加1;
if(src.length>=this.size){//如果小于规模
src[size-1]=e;
}else{
//开辟新的数组;
Object[]dest =new Object[src.length+this.IncreseSize];
//拷贝数组;
    for(int i=0;i<src.length;i++){
    dest[i]=src[i];
    }
    dest[src.length]=e;
    src=dest;
}
}

/**
* 得到数组制定位置的元素;
* @param index
* @return
*/
@SuppressWarnings("unchecked")
public E get(int index){
if(index>=this.size){
System.out.println("数组越界!");
return null;
}else{
return (E) src[index];
}


}

/**
* 修改制定位置出的元素;
* @param s
* @param index
*/
public void modify(E e,int index){
src[index]=e;
}

public int getIncreseSize() {
return IncreseSize;
}
public void setIncreseSize(int IncreseSize) {
this.IncreseSize = IncreseSize;
}
/**
* 向指定的位置添加元素;
* @param s
* @param index
*/
public void insert(E e,int index){
this.size++;//长度加1;
if(src.length>=this.size){//如果小于规模
for(int i=this.size-1;i>index;i--){
src[i]=src[i-1];
}
src[index]=e;
}else{
//开辟新的数组;
Object[]dest =new Object[src.length+this.IncreseSize];
//拷贝数组;
    for(int i=0;i<index-1;i++){
    dest[i]=src[i];
    }
    //再拷贝 ;
    for(int i=index;i<this.size;i++){
    dest[i+1]=src[i];
    }
    dest[index]=e;
    src=dest;
}
}

/**
* 得到队列的长度;
* @return
*/
public int size(){
return this.size;
}

/**
* 删除指定位置的元素
* @param index
*/
public void delete(int index){
this.size--;
        for(int i=index+1;i<src.length;i++){
        src[i-1]=src[i];
        }
}


}
以上队列有两个好处：除了在使用的时候才需要指定队列之外，在队列的动态扩展方面做了很好的处理！我们先开辟了一个定长的数组，然后在每次向队列中加入或插入元素的时候如果超出了队列的现有长度就再开辟一个定长的空间！相对于每次添加元素是重新开辟空间复制数组在效率上有了很大的提高！
再有就是Java泛型中的那个E或是e，呵呵，它只是一种不确定类型的代替而已！因为在定义泛型的时候我们不知道它的实际对象是什么，所以用E来代替，其实也可以换成其它的字符！