数组队列总结

1.数组的优点和缺点

数组的优点：1.存取方便 2.查找速度

数组的缺点：1.长度固定 2.存储的数据类型是固定的。

 

2.数组队列的实现思路

1）.对象名中存储的是什么内容？

对象名中存储的是地址。

int [] array = new int[0]; array = new int[1];

Java中有GC（垃圾回收机制），自动销毁没有使用的对象，释放内存空间。就相当于C++中的析构函数

1.借助于对象名中存储的地址，每一次创建一个新的数组，是原始数组的长度加1或者长度减1.

2.原始数组中存储的数据，存入到新数组中，然后再去添加新的元素或者不需要添加

 

 

3.数组队列的实现步骤

1）.定义一个接口，在接口中定义抽象方法。

2）.定义一个类，实现接口，重写接口中的抽象方法。

3）.在类中定义一个原始数组和数组的元素总数属性。

4.实现添加元素的方法

a.新建一个数组，数组的长度是原始数组的长度加1。

b.将原始数组中的内容复制到新数组中。

c.将要添加的元素添加到新数组的最后一位。

d.将新数组名中存储的地址赋给原始数组名。

5.实现删除元素的方法 和第四步是类似的。

6.获取元素的总数呢？ 添加元素的时候，元素总数属性加1；删除元素的时候，元素总数属性减1；返回元素总数属性值 7.查找对应的元素方法

a.判断索引是否在下标允许的范围之内。

b.数组[下标]的方式直接获取元素。

 

4.Java的泛型 泛型 表示符号是E E可以表示Java中的任意一种数据类型。

 

package 数组队列;

/**
 * 数组队列的测试demo类
 * 
 * @author xxj
 * 
 */
public class ArrayListDemo {

	public static void main(String[] args) {
		// 实例化一个数组队列对象。
		MyArrayList mal = new MyArrayListImpl();
		mal.add("字符串---");// 向队列中添加元素
		for (int i = 0; i < 5; i++) {
			mal.add(i);//调用添加元素的方法
		}
		mal.add("结束");
		// 输出信息
		for (int i = 0; i < mal.size(); i++) {
			System.out.println(mal.get(i));
		}
		System.out.println();
		//调用删除的方法
		mal.remove(5);
		// 输出信息
		for (int i = 0; i < mal.size(); i++) {
			System.out.println(mal.get(i));
		}
		System.out.println();
		
		//将指定的元素插入此列表中的指定位置。
		mal.add(2,"add方法插入到下标为2的位置" );
		// 输出信息
		for (int i = 0; i < mal.size(); i++) {
			System.out.println(mal.get(i));
		}
		System.out.println();
		
		//移除此列表中首次出现的指定元素（如果存在）。
		mal.remove("结束");
		// 输出信息
		for (int i = 0; i < mal.size(); i++) {
			System.out.println(mal.get(i));
		}
		System.out.println();
		
		//用指定的元素替代此列表中指定位置上的元素。
		mal.set(2, "element");
		// 输出信息
		for (int i = 0; i < mal.size(); i++) {
			System.out.println(mal.get(i));
		}
		System.out.println();
		
		//返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1。
		System.out.println("1第一次出现的索引"+mal.indexOf(1));
		
		//返回此列表中最后一次出现的指定元素的索引，或如果此列表不包含索引，则返回 -1。
		System.out.println("1最后一次出现的索引"+mal.indexOf(1));
		
		//如果此列表中没有元素，则返回 true
		System.out.println(mal.isEmpty());
		
		//移除此列表中的所有元素
		mal.clear();
		// 输出信息
		for (int i = 0; i < mal.size(); i++) {
			System.out.println(mal.get(i));
		}
		System.out.println("移除此列表中的所有元素后，是否为空： "+mal.isEmpty());
	
		
	}

}

 

package 数组队列;

/**
 * 数组队列接口
 * @author xxj
 *
 */
public interface MyArrayList<E> {
	
	public void add(E e);//添加元素的方法
	public boolean remove(int index);//移除元素的方法
	
	public int size();//获取数组队列的元素总数
	public E get(int index);//获取指定索引位置的元素
	
	//将指定的元素插入此列表中的指定位置。 
	public void add(int index, E element);
	
	//移除此列表中的所有元素 
	public void clear();
	
	//返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1。
	public int indexOf(Object o);
	
	//如果此列表中没有元素，则返回 true 
	public boolean isEmpty();
	
	// 返回此列表中最后一次出现的指定元素的索引，或如果此列表不包含索引，则返回 -1。
	public int lastIndexOf(Object o);   
	
	//移除此列表中首次出现的指定元素（如果存在）。
	public boolean remove(Object o);
	
	//用指定的元素替代此列表中指定位置上的元素。
	public E set(int index, E element);
	

}

 

package 数组队列;

/**
 * 自定义的数组队列实现类，该类要实现MyArrayList接口
 * 
 * @author xxj
 * 
 */
public class MyArrayListImpl<E> implements MyArrayList<E> {

	// 声明一个原始数组对象，长度是0
	private Object[] array;
	// 声明一个存储数组中元素的总数变量
	private int size = 0;

	/**
	 * 构造方法
	 */
	public MyArrayListImpl() {
		array = new Object[0];
	}

	/**
	 * 构造方法
	 */
	public MyArrayListImpl(int size) {
		array = new Object[size];
	}

	/**
	 * 向队列的末尾添加元素
	 */
	public void add(E e) {
		// 定义一个新的数组，该数组的长度是原始数组的长度加1
		Object newarray[] = new Object[size + 1];
		// 将原始数组中的内容复制到newarray
		for (int i = 0; i < size; i++) {
			// 复制操作
			newarray[i] = array[i];
		}
		// 将新元素添加newarray数组的最后一个位置
		newarray[size] = e;
		// 统计元素个数的计数器要加1
		size++;
		// 交换地址
		array = newarray;
	}

	/**
	 * 从队列中移除指定索引位置的元素
	 */
	public boolean remove(int index) {
		// 定义一个新的数组，该数组的长度是原始数组的长度减1
		Object newarray[] = new Object[size - 1];
		// 判断index索引是否在范围之内
		if (index >= 0 && index < size){
			// 将原始数组中的内容复制到newarray
			for(int i=0;i<index;i++){
				// 复制操作
				newarray[i] = array[i];
			}
			for(int i=index+1;i<size;i++){
				// 复制操作
				newarray[i-1] = array[i];
			}
		}else{
			return false;
		}
		// 统计元素个数的计数器要减1
		size--;
		// 交换地址
		array = newarray;
		return true;
	}

	/**
	 * 获取数组队列中的元素总数
	 */
	public int size() {
		return size;
	}

	/**
	 * 获取数组队列中指定索引位置的元素
	 */
	public E get(int index) {
		// 判断index索引是否在范围之内
		if (index >= 0 && index < size){
			return (E)array[index];
		}
		return null;
	}

	/**
	 * 将指定的元素插入此列表中的指定位置。
	 */ 
	public void add(int index, E element){
		// 定义一个新的数组，该数组的长度是原始数组的长度加1
		Object newarray[] = new Object[size+1];
		if (index >= 0 && index < size){
			// 将原始数组中的内容复制到newarray
			for(int i=0;i<index;i++){
				// 复制操作
				newarray[i] = array[i];
			}
			newarray[index] = element;
			for(int i=index+1;i<size+1;i++){
				// 复制操作
				newarray[i] = array[i-1];
			}
		}
		// 统计元素个数的计数器要加1
		size++;
		// 交换地址
		array = newarray;
	}
	
	/**
	 * 移除此列表中的所有元素
	 */ 
	public void clear(){
		// 定义一个新的数组，该数组的长度是0
		Object newarray[] = new Object[0];
		size=0;
		// 交换地址
		array = newarray;
	}
	
	/**
	 * 返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1。
	 */
	public int indexOf(Object o){
		//遍历数组，查找此列表中首次出现的指定元素的位置
		for(int i=0;i<size;i++){
			//判断首次出现的指定元素的位置
			if(array[i]==o){
				return i;
			}
		}
		return -1;
	}
	
	/**
	 * 如果此列表中没有元素，则返回 true
	 */ 
	public boolean isEmpty(){
		for(int i=0;i<size;i++){
			//判断数组中是否有元素不为空
			if(array[i]!=null){
				return false;
			}
		}
		return true ;
	}
	
	/**
	 * 返回此列表中最后一次出现的指定元素的索引，或如果此列表不包含索引，则返回 -1。
	 */
	public int lastIndexOf(Object o){
		//遍历数组，从后往前查找第一次出现的指定元素
		for(int i=size-1;i>0;i--){
			//判断从后往前查找第一次出现的指定元素的位置
			if(array[i]==o){
				return i;//返回索引
			}
		}
		return -1;
	}  
	
	/**
	 * 移除此列表中首次出现的指定元素（如果存在）。
	 */
	public boolean remove(Object o){
		// 定义一个新的数组，该数组的长度是原始数组的长度减1
		Object newarray[] = new Object[size - 1];
		for(int j=0;j<size;j++){
			if(array[j]==o){
				// 将原始数组中的内容复制到newarray
				for(int i=0;i<j;i++){
					// 复制操作
					newarray[i] = array[i];
				}
				for(int i=j+1;i<size;i++){
					// 复制操作
					newarray[i-1] = array[i];
				}
				// 统计元素个数的计数器要减1
				size--;
				// 交换地址
				array = newarray;
				return true;
				}
		}
		return false;	
	}
	
	/**
	 * 用指定的元素替代此列表中指定位置上的元素。
	 */
	public E set(int index, E element){
		//用指定的元素替代此列表中指定位置上的元素
		array[index]=element;
		return element;
	}	
}