数组与队列，队列与泛型

数组与队列的特点，区别，及应用场景
数组：长度一旦定义就不能改变，并且在内存中的地址是连续的。
队列：在允许的范围内，长度可以根据需要而改变，类型也可以改变。缺点是只能放入一个种类（或其子类）的对象。于是我们可以通过定义一个队列了来改变队列的类型。
泛型：不知道队列的类型或者想改变队列的类型时使用。
队列：
主类：
/**
* 自定义队列类（动态数组）
* 长度可以改变，但只能存整数
* 增加，得到，修改，删除，插入元素，得到长度
* @author Administrator
*
*/
public class MyList {

//定义一个长度为0的原始数组
private int[] src = new int[0];



/**
* 将指定的数据放入队列容器中
*
* @param num
*            要放入队列容器的数据
*/
public void add(int num) {
//定义一个新数组，长度是原始数组长度+1
int dest[] = new int[src.length+1];

//将新元素放入新数组最后一个下标位置
dest[src.length] = num;
//将原始数组中的元素按照下标顺序拷贝到新数组
for(int i=0;i<src.length;i++){
dest[i] = src[i];
}

//将原数组名指向新数组
src = dest;
}

/**
* 取出指定下标位置的元素
*
* @param index
*            要取出的元素的下标
* @return 返回取得的元素
*/
public int get(int index) {
//得到src对应下标的元素
int num = src[index];
return num;
}

/**
* 删除指定位置的元素
*
* @param index
*            要删除的元素的下标
*/
public void delete(int index) {
//定义一个新数组，长度是原始数组长度-1
int dest1[] = new int[src.length-1];

//将原始数组中的元素按照下标顺序拷贝到新数组
for(int i=0;i<dest1.length;i++){
dest1[i] = src[i+1];
}

//将原数组名指向新数组
src = dest1;

}

/**
* 将指定位置的元素修改为指定的值
*
* @param index
*            要修改的元素的下标
* @param num
*            修改之后的新值
*/
public void modify(int index, int num) {
src[index] = num;
}

/**
* 在指定的位置插入指定的元素值
*
* @param index
*            要插入元素的位置
* @param num
*            要插入的元素
*/
public void insert(int index, int num) {

}

/**
* 得到容器中元素个数的方法
*
* @return 返回容器中的元素个数
*/
public int size() {
//队列长度就是src数组的当前长度
int len = src.length;
return len;
}

}

测试类：
/**
* 队列测试类
*
* @author Administrator
*
*/
public class ListTest {

public static void main(String args[]) {

// 创建一个队列对象
MyList list = new MyList();

// 放入10个元素
for (int i = 0; i < 10; i++) {
list.add(i*100);
}


//在增加一个
//list.add(10000);
list.delete(2);
//list.modify(0, 1234);

//遍历
for(int i=0;i<list.size();i++){
//根据下标取出元素
int num = list.get(i);
System.out.println(num);
}






}

}





泛型：
主类：
/**
* 自定义队列类（动态数组）
* E: 表示容器中将要存放的数据类型，没有确定是什么类型，是泛指一种类型
* @author Administrator
*
*/
public class MyListFan<E> {

//定义一个长度为0的原始数组
//将数组定义为Object数组，表示能存放Java中所有的对象
private Object[] src = new Object[0];



/**
* 将指定的数据放入队列容器中
*
* @param e
*            要放入队列容器的数据
*/
public void add(E e) {
//定义一个新数组，长度是原始数组长度+1
Object dest[] = new Object[src.length+1];

//将新元素放入新数组最后一个下标位置
dest[src.length] = e;
//将原始数组中的元素按照下标顺序拷贝到新数组
for(int i=0;i<src.length;i++){
dest[i] = src[i];
}

//将原数组名指向新数组
src = dest;
}

/**
* 取出指定下标位置的元素
*
* @param index：要取出的元素的下标
*           
* @return 返回取得的元素
*/
public E get(int index) {
//得到src对应下标的元素，强制转型
E e = (E) src[index];
return e;
}

/**
* 删除指定位置的元素
*
* @param index
*            要删除的元素的下标
*/
public void delete(int index) {

}

/**
* 将指定位置的元素修改为指定的值
*
* @param index：要修改的元素的下标
*           
* @param num：修改之后的新值
*           
*/
public void modify(int index, E e) {
src[index] = e;
}

/**
* 在指定的位置插入指定的元素值
*
* @param index：要插入元素的位置
*           
* @param e：要插入的元素
*           
*/
public void insert(int index, E e) {

}

/**
* 得到容器中元素个数的方法
*
* @return 返回容器中的元素个数
*/
public int size() {
//队列长度就是src数组的当前长度
int len = src.length;
return len;
}

}

测试类
/**
* 测试泛型队列
*
* @author Administrator
*
*/
public class ListTest {

public static void main(String args[]) {

// 创建队列,用来存储字符串
MyListFan<String> list = new MyListFan<String>();

//装入元素
for (int i = 0; i < 10; i++) {
String s = "元素" + i;
list.add(s);
}

//遍历
for(int i=0;i<list.size();i++){
//根据下标取出一个元素
String s = list.get(i);
System.out.println(s);
}


}
}