数组队列

  

                                                                          数组队列的一些知识 

 数组的优点和缺点
 数组有哪些优点
  线性结构的存储方式（连续存储空间）
  数据的读取速度快。
  
 数组有哪些缺点
  1.数组中只能存储一种数据类型。
  2.开辟的空间是固定的。

 2  数组队列的实现思路
 1.定义数组，数组名中存储的是什么？
  内存的首地址
 2.如果改变数组名中存储的地址，那么数组指向的内存空间是不是改变了？
  int [] array = new int[10];
  array = new int[11];
 
3.数组队列的实现步骤
 1.定义一个类，类中有两个属性：一个是数组，一个元素总数；
 2.定义构造方法，实例化数组对象；
 3.定义添加元素的方法
  1.建立一个新的数组，该数组的长度是元素总数的长度加1
  2.循环属性数组中的内容，存入到新数组中
  3.将要添加的元素放到新数组的最后一个位置
  4.元素总数要加1
  5.将新数组名中存储的地址给属性数组。
 4.定义删除元素的方法
 5.定义返回元素总数的方法
 6.定义一个方法用来获取指定索引位置的元素。

4.Java的泛型
 泛型是使用E来表示。
 E表示什么？
  表示的是存储的数据类型，E是没有确定的类型的。
  E不是Java的任何一种数据类型,只是一个符号，可以用Java的任何一种
  引用数据类型来代入。
  E就是用来表示Java中的任意一种数据类型。
  
 Object是Java所有类的父类。

package Arraylist;

import java.util.Collection;

public interface MyArraylist<E> {
	
	public void add(E e);//添加元素的方法
	public boolean remove(int index);//移除元素的方法
	
	public int size();//获取数组队列的元素总数
	public E get(int index);//获取指定索引位置的元素
	public  boolean add1(E e);//将指定的元素添加到此列表的尾部。
	 public  boolean add(int index, E element);// 将指定的元素插入此列表中的指定位置。
	 public boolean addAll(Collection<? extends E> c) ;  //按照指定 collection 的迭代器所返回的元素顺序，将该 collection 中的所有元素添加到此列表的尾部。 
        
	public	void clear()  ;  //移除此列表中的所有元素           
	             
	public 	 int indexOf() ;  //    返回此列表中指定位置上的元素 
	public 	  boolean isEmpty() ;    //返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1。       
	public 	int lastIndexOf(Object o1);    //如果此列表中没有元素，则返回 true
	public 	E remove1(int index) ;   //     移除此列表中指定位置上的元素。 
	 public	boolean remove(Object o) ; //  移除此列表中首次出现的指定元素（如果存在）。 
	public	E set(int index, E element);// 用指定的元素替代此列表中指定位置上的元素。 
	    
	 
	
}

 

package Arraylist;







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

	public static void main(String[] args) {
		// 实例化一个数组队列对象。
		MyArraylist<Object> mal = new MyArrayListImpl<Object>();
		mal.add("字符串");// 向队列中添加元素
		for (int i = 0; i < 10; i++) {
			mal.add(i);//调用添加元素的方法
		}
		
		mal.add(new MyArrayListImpl<Object>());
		

		// 输出信息
		for (int i = 0; i < mal.size(); i++) {
			System.out.println(mal.get(i));
		}
		//调用删除的方法
		mal.remove(5);
		// 输出信息
		for (int i = 0; i < mal.size(); i++) {
			System.out.println(mal.get(i));
		}
		//调用指定位置添加对象的方法
		mal.add(3,"字符串");
		for (int i = 0; i < mal.size(); i++) {
			
			System.out.println(mal.get(i));
		
	}
	}

}

   

package Arraylist;

import java.util.Collection;



/**
 * 自定义的数组队里实现类，该类要实现MyArrayList接口
 * 
 * @author lby
 * 
 */
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 array.length;
	}

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

	//将指定的元素添加到此列表的尾部。
	public boolean add1(E e) {
		
		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;
		return false;
	}

	// 将指定的元素插入此列表中的指定位置。
	public  boolean add(int index, E e) {
		
		Object [] obj=new Object[size+1];
		for(int i=0;i<index;i++)
		{
			System.out.println("hhih");
		obj[i]=array[i];
		}
		obj[index]=e;//添加新元素到指定位置
		for(int j=index;j<size;j++)//将后面的元素加进去
		{
			obj[j+1]=array[j];
			System.out.println("hhih");
		}
	array=obj;
		return false;
		
		
		
		
	}

	//按照指定 collection 的迭代器所返回的元素顺序，将该 collection 中的所有元素添加到此列表的尾部。 
	  
	public boolean addAll(Collection<? extends E> c) {
		
		return false;
	}

	 //移除此列表中的所有元素    
	public void clear() {
		
		Object[] obj=new Object[0];
		array=obj;
		
	}

	 //    返回此列表中指定位置上的元素 
	public int indexOf() {
		Object o1 = null;
		int length=array.length;
		for(int i=0;i<=length;i++)
		{
			if(array[i]==o1)
			return i;
		}
		return -1;
		
		
	}

	//返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1。
	public boolean isEmpty() {
		
		return size()==0;
	}

	 //如果此列表中没有元素，则返回 true
	public int lastIndexOf(Object o1) {
		int length=array.length;
		for(int i=length-1;i<=0;i--)
		{
			if(array[i]==o1)
			return i;
		}
		return -1;
	}

//  移除此列表中指定位置上的元素。 
	@SuppressWarnings("unchecked")
	public E remove1(int index) {
		int length=array.length;//设置数组的长度
		Object [] obj=new Object[length+1];//重新定义新的数组
		for(int i=0;i<index;i++)
		{
			
		obj[i]=array[i];//保留数组
		}
		
		for(int j=index+1;j<length+1;j++)
		{
			obj[j-1]=array[j];
		}
		array=obj;
		
		if(index>size||index<0)
		System.out.println("+index+"+index+size+",size");
		return (E)obj[index];
	}

//  移除此列表中首次出现的指定元素（如果存在）。
	public boolean remove(Object o1) {
		int length=array.length;
		for(int i=0;i<=length;i++)
		{
			if(array[i]==o1)
			return true;
		}
		return false;
		
		
	}

	// 用指定的元素替代此列表中指定位置上的元素
	public E set(int index, E e) {
		int length=array.length;
		Object [] obj=new Object[length+1];
		for(int i=0;i<index;i++)
		{
			
		obj[i]=array[i];
		}
		obj[index]=e;//添加指定的元素
		for(int j=index;j<length+1;j++)
		{
			obj[j]=array[j];
		}
		array=obj;
		
		if(index>size||index<0)
		System.out.println("+index+"+index+size+",size");
		return (E)obj[index];
	}

	
	

}