猫狗队列

题目：

 宠物，狗和猫的类如下：

    public class Pet{

        private String type;

        public Pet(String type){

            this.type=type;

        }

        public String getPetType(){

            return this.type;

        }

    }

    public class Dog extends Pet{

        public Dog(){

            super("dog");

        }

    }

    public class Cat extends Pet{

        public Cat(){

            super("cat");

        }

    }

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

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

    2.  用户可以调用pollAlll方法,将队列所有的实例按照进队列的先后顺序依次弹出；

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

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

    5.用户可以调用isEmpty方法,检查队列中是否还有dog或cat的实例;

    6.用户可以调用isDogEmpty方法,检查队列中是否还有dog的实例;

    7.用户可以调用isCatEmpty方法,检查队列中是否还有cat的实例;

解法：

分别用两个队列保存cat和dog，并建立一个新类PetEnterQueue为Cat和dog加入时间戳，好区分进入先后，并且不改变前面的类。然后在

队列中加入实例时，如果是dog（cat）生成对应的PetEnterQueue实例。放入队列中。弹出就判断时间戳，count小的先出来

代码如下：

package dogcatqueue;

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 pet;
	}
	public void setPet(Pet pet) {
		this.pet = pet;
	}
	public long getCount() {
		return count;
	}
	public void setCount(long count) {
		this.count = count;
	}
	public String getEnterPetType(){
		return pet.getPetType();
	}
}

package dogcatqueue;


import java.util.LinkedList;
import java.util.Queue;


public class DogCatQueue {
	private Queue<PetEnterQueue> dogQ;
	private long count;
	private Queue<PetEnterQueue> catQ;
	
	public void DogCatQueue(){
		dogQ = new LinkedList<PetEnterQueue>();
		count =0;
		catQ = new LinkedList<PetEnterQueue>();
	}
	//加入队列，时间戳count++。
	public void add(Pet pet){
		if(pet.getPetType().equals("dog")){
			dogQ.add(new PetEnterQueue(pet, count++));
		}else if(pet.getPetType().equals("cat")){
			catQ.add(new PetEnterQueue(pet,count++));


		}else{
			throw new RuntimeException("err");
		}
	}
	//根据时间戳count大小从队列中弹出
	public Pet pollAll(){
		if(!dogQ.isEmpty()&&!catQ.isEmpty()){
			if(dogQ.peek().getCount()<catQ.peek().getCount()){
				return dogQ.poll().getPet();
			}else{
				return catQ.poll().getPet();
			}
		}else if(!dogQ.isEmpty()){
			return dogQ.poll().getPet();
		}else if(!catQ.isEmpty()){
			return catQ.poll().getPet();
		}else{
			throw new RuntimeException("err,queue is empty");
		}
		
	}
	public Pet pollDog(){
		if(!isDogQueueEmpty()){
			return dogQ.poll().getPet();
		}else{
			throw new RuntimeException("err");
		
		}
	}
	public Pet pollCat(){
		if(!isCatQueueEmpty()){
			return dogQ.poll().getPet();
		}else{
			throw new RuntimeException("err");
		
		}
	}
	
	public boolean isEmpty(){
		return dogQ.isEmpty()&&catQ.isEmpty();
	}
	public boolean isDogQueueEmpty(){
		return dogQ.isEmpty();
	}
	public boolean isCatQueueEmpty(){
		return catQ.isEmpty();
	}
}

学习至左程云老师《程序员代码面试指南》