数组队列基本功能实现

数组队列基本功能的实现

一、概述

数组队列的本质就是一个数组，其基本功能就是初始化、增、删、查、改等。用如下的接口来进行方法抽象，规定基本功能。

public interface MyList<E>{
    /**
     *
     * @return 存储的元素个数
     */
    int size();

    /**
     * @param value 添加的元素 
     */
    void add(E value);

    /**
     * 合并
     * @param list 需要合并的List
     */
    void addAll(MyList list);

    /**
     * 合并一个对象数组
     * @param objects
     */
    void addAll(E[] objects);
    /**
     * 获取：
     * @param index 根据下标获取
     * @return 返回元素对象
     */
    Object get(int index);

    /**
     * 根据元素查找 
     * @param value
     * @return 下标数组
     */
    int[] get(E value);

    /**
     * 根据下标删除
     * @param index
     */
    void remove(int index);

    /**
     * 根据元素对象值删除
     * @param value
     */
    void remove(E value);

    /**
     * 清空队列 
     */
    void removeAll();


    /**
     *
     * @param index 目标元素的下标
     * @param value 目标元素需要替换的对象
     */
    void set(int index,E value);

    /**
     *
     * @param repobj 目标元素对象
     * @param value 目标元素需要替换的对象
     */
    void set(E repobj,E value);


    /**
     * 排序 对象的 hashcode 
     */
    void sort();




}

二、实现

1. 类中的元素以及初始化如下，主要表示队列的长度及元素。

   public int size;
   public int length;
   public Object[] value;
   public final int MAX_length=Integer.MAX_VALUE;
   public final int MIN_length=10;

   public MyArraylist(int l){
       size=0;
       if(l<MIN_length)
           l=MIN_length;
       value=new Object[l];
       length=l;
   }

2. size()很简单，只要返回size即可。

public int size() {
        return this.size;
    }

3.三种add也不复杂，主要部分就是修改size、length和value。

	@Override
	public void add(E value) {
        if(this.size==length){
            int newlength=(length>>1)+length;
            Object[] newvalue=new Object[newlength];
            for(int i=0;i<length;i++){
                newvalue[i]=this.value[i];
            }
            length=newlength;
            this.value=newvalue;
            size++;
        }
        else {
            size++;
            this.value[size-1]=value;
        }
    }

    @Override
    public void addAll(MyList list) {
        if((this.size+list.size())>length){
            int templ=this.size+list.size();
            int newlength=(templ>>1)+templ;
            Object[] newvalue=new Object[newlength];
            for(int i=0;i<this.size;i++){
                newvalue[i]=this.value[i];
            }
            for(int i=0;i<list.size();i++){
                newvalue[this.size+i]=list.get(i);
            }
            length=newlength;
            this.value=newvalue;
            this.size+=templ;
        }
        else {
            this.size+=list.size();
            for(int i=0;i<list.size();i++){
                value[this.size+i]=list.get(i);
            }
        }

    }

    @Override
    public void addAll(E[] objects) {
        if((this.size+objects.length)>length){
            int templ=this.size+objects.length;
            int newlength=(templ>>1)+templ;
            Object[] newvalue=new Object[newlength];
            for(int i=0;i<this.size;i++){
                newvalue[i]=this.value[i];
            }
            for(int i=0;i<objects.length;i++){
                newvalue[this.size+i]=objects[i];
            }
            length=newlength;
            this.value=newvalue;
            this.size+=templ;
        }
        else {
            this.size+=objects.length;
            for(int i=0;i<objects.length;i++){
                value[this.size+i]=objects[i];
            }
        }
    }

4. 获取元素时要注意下镖是否发生越界。

@Override
    public Object get(int index) {
        if(index<0||index>=length)
            return null;
        else{
            return value[index];
        }
    }

    @Override
    public int[] get(E value) {
        int judge=0;
        int[] ans=new int[size];
        for(int i=0;i<size;i++){
            if(this.value[i]==value){
                ans[judge]=i;
                judge++;
            }
        }
        int[] ans2=new int[judge];
        for(int i=0;i<judge;i++){
            ans2[i]=ans[i];
        }
        return ans2;
    }

5. 删除元素也要注意目标是否有越界，以及删除最后一个元素的特殊情况。

public void remove(E value) {
        int temp=size;
        for(int i=0;i<temp;i++){
            if(this.value[i]==value){
                remove(i);
                size--;
            }
        }
    }

    @Override
    public void removeAll() {
        size=0;
        Object[] newvalue=new Object[length];
        value=newvalue;
    }

6. 修改元素也要注意目标是否有越界。

@Override
    public void set(int index, E value) {
        if(index<0||index>=size)
            return;
        else{
            this.value[index]=value;
        }
    }

    @Override
    public void set(E repobj, E value) {
        for(int i=0;i<size;i++){
            if(this.value[i]==repobj)
                this.value[i]=value;
        }
    }

7. 队列的排序是根据队列元素的hashcode()值来进行的，用一个HashMap记录hashcode()与位置的映射。

@Override
    public void sort() {
        int[]hash=new int[size];
        HashMap<Integer,Integer> map = new HashMap<Integer,Integer>();
        for(int i=0;i<size;i++){
            map.put(value[i].hashCode(),i);
            hash[i]=value[i].hashCode();
        }
        Arrays.sort(hash);
        Object[] newvalue=new Object[length];
        for(int i=0;i<size;i++){
            newvalue[i]=value[map.get(hash[i])];
        }
        value=newvalue;
    }