猫狗队列（java实现）

一、题目

       宠物、狗和猫的类如下

  public class Pet {

   private String type;
   public Pet(String type) {
          this.type = type;   
   }
   public String getPetType() {
  return type;
   }

}

public class Dog extends Pet{
      public  Dog() {
      super("dog");
}
}

public class Cat extends Pet{
      public Cat() {
     super("cat");
      }

}

实现一种狗猫队列的结构，要求如下：

（1）用户可以调用add方法将cat类或dog类的实例放入队列中；

（2）用户可以调用pollAll方法，将队列中所有的实例按照进队列的先后顺序依次弹出；

（3）用户可以调用pollDog方法，将队列中dog类的实例按照进队列的先后顺序依次弹出；

（4）用户可以调用pollCat方法，将队列中cat类的实例按照进队列的先后顺序依次弹出；

（5）用户可以调用isEmpty方法，检查队列中是否还有dog或cat的实例；

（6）用户可以调用isDogEmpty方法，检查队列中是否还有dog类的实例；

（7）用户可以调用isCatEmpty方法，检查队列中是否还有cat类的实例。

二、解答

     实现思路我们其实是想把每次进入队列的实例都加上时间戳的方法，但不能改变原有的数据结构，所以只能定义一个新类来封装时间戳，具体实现如下PetEnterQueue类：

public class PetEnterQueue {
         private Pet pet;
         private long count;
         
         public PetEnterQueue(Pet pet,long count) {
        	 this.pet = pet;
        	 this.count = count;
         }
         
         public Pet getPet() {
        	 return this.pet;
         }
         
         public long getCount() {
        	 return this.count;
         }
         
         public String getEnterPetType() {
        	 return this.pet.getPetType();
         }
}

            上述代码中的count就是我们加上的时间戳。队列里存放的就是PetEnterQueue实例。

DogCatQueue类的整体代码如下：

import java.beans.PersistenceDelegate;
import java.util.LinkedList;
import java.util.Queue;

public class DogCatQueue {
        private Queue<PetEnterQueue> dogQ;
        private Queue<PetEnterQueue> catQ;
        private long count;
        
        public DogCatQueue() {
        	this.dogQ = new LinkedList<PetEnterQueue>();
        	this.catQ = new LinkedList<PetEnterQueue>();
        	this.count = 0;
        }
        
        public void add(Pet pet) {
        	if(pet.getPetType().equals("dog")) {
        		this.dogQ.add(new PetEnterQueue(pet, this.count++));
        	}else if(pet.getPetType().equals("cat")) {
        		this.catQ.add(new PetEnterQueue(pet, count++));
        	}else {
        		throw new RuntimeException("error,not dog or cat");
        	}
        }
        
        public Pet pollAll() {
        	if(!this.dogQ.isEmpty() && !this.catQ.isEmpty()) {
        		if(this.dogQ.peek().getCount() < this.catQ.peek().getCount()) {
        			return this.dogQ.poll().getPet();
        		}else {
        			return this.catQ.poll().getPet();
        		}
        	}else if(!this.dogQ.isEmpty()) {
        		return this.dogQ.poll().getPet();
        	}else if(!this.catQ.isEmpty()) {
        		return this.catQ.poll().getPet();
        	}else {
        		throw new RuntimeException("err,queue is empty");
        	}
        }
        
        public Dog polldog() {
        	if(!this.dogQ.isEmpty()) {
        		return (Dog)this.dogQ.poll().getPet();
        	}else {
        		throw new RuntimeException("Dog Queue is empty!");
        	}
        }
        
        public Cat pollcat() {
        	if(!this.catQ.isEmpty()) {
        		return (Cat)this.catQ.poll().getPet();
        	}else {
        		throw new RuntimeException("Cat Queue is empty!");
        	}
        }
    
        public boolean isEmpty(){
        	return this.dogQ.isEmpty()&&this.catQ.isEmpty();
        }
        
        public boolean isDogQueueEmpty() {
        	return this.dogQ.isEmpty();
        }
        
        public boolean isCatQueueEmpty() {
        	return this.catQ.isEmpty();
        }
}