第四题：猫狗队列问题

题目要求：

现有猫狗类如下：

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

    public String getType() {
        return type;
    }
}

class Dog extends Pet{

    public Dog(String type) {
        super(type);
    }
}

class Cat extends Pet{

    public Cat(String type) {
        super(type);
    }
}

实现猫狗队列的结构：
①用户可以调用add方法将Cat类或者是Dog类实例放入到队列中
②用户可以调用pollAll方法，将队列中所有的实例按照进入队列的顺序依次弹出
③用户可以调用pollDog方法，将队列中的dog类实例按照进入队列的顺序依次弹出
④用户可以调用pollCat方法，将队列中的dog类实例按照进入队列的顺序依次弹出
⑤用户可以调用isEmpty方法，检查队列中是否还有dog，或者cat的实例
⑥用户可以调用isCatEmpty方法，检查队列中是否有cat的实例
⑦用户可以调用isDogEmpty方法，检查队列中是否有dog的实例

代码实现与思路分析：

package com.isea.brush.cat_dog_queue;

import java.util.LinkedList;

/**
 * 实现思路：
 * 定义一个宠物进队的内部类PetEnterQ，该类完成宠物+时间戳的封装，进入队列的将是该内部类PetEnterQ实例
 * 定义一个CatQ和一个DogQ，分别用户装Cat实例和Dog实例
 * 入队的时候，判断Pet类型，Cat进入CatQ，Dog进入DogQ
 * 整体出队的时候，拿出CatQ队首的cat实例，在拿出DogQ队首的dog实例，比较时间戳较小这出队
 * DogQ和CatQ分别出队的时候，直接弹出队首的元素即可
 * 队列判空需要对DogQ 和 CatQ分别判空
 */
public class DogCatQueue {

    private LinkedList<PetEnterQ> catQ;
    private LinkedList<PetEnterQ> dogQ;
    public long count;

    private class PetEnterQ{
        private Pet pet;
        private long count;

        public PetEnterQ(){
        }
        public PetEnterQ(Pet pet,long count){
            this.pet = pet;
            this.count = count;
        }

        public Pet getPet(){
            return pet;
        }
        public String getPetType(){
            return pet.getType();
        }

        public long getCount() {
            return count;
        }
    }

    public DogCatQueue(){
        dogQ = new LinkedList<PetEnterQ>();
        catQ = new LinkedList<PetEnterQ>();
        count = 0;
    }

    /**
     * 向队列中添加宠物
     * @param pet
     */
    public void add(Pet pet){
        if (pet.getType().equals("dog")){
            dogQ.add(new PetEnterQ(new Dog("dog"),count ++));
        }else if (pet.getType().equals("cat")){
            catQ.add(new PetEnterQ(new Cat("cat"),count ++));
        }
    }

    /**
     * cat出队列
     * @return
     */
    public Cat pollCat(){
        if (isCatQEmpty()){
            throw new IllegalArgumentException("The catQ is empty...");
        }
        return (Cat) catQ.poll().getPet();
    }

    /**
     * dog出队列
     * @return
     */
    public Dog pollDog(){
        if (isDogQEmpty()){
            throw new IllegalArgumentException("The DogQ is empty....");
        }
        return (Dog) dogQ.poll().getPet();
    }

    /**
     * 宠物出队
     * @return
     */
    public Pet pollPet(){
        if (isQEmpty()){
            throw new IllegalArgumentException("The Queue is empty...");
        }else if (isCatQEmpty() && !isDogQEmpty()){ //catQ为空，dogQ非空
            return pollDog();
        }else if (isDogQEmpty() && !isCatQEmpty()){ //dogQ为空，catQ非空
            return pollCat();
        }else { //dogQ非空，catQ非空
            PetEnterQ cat =  catQ.peek();
            PetEnterQ dog = dogQ.peek();
            return  cat.getCount() < dog.getCount() ?  cat.getPet() : dog.getPet();
        }
    }

    /**
     * catQ 队列判空
     * @return
     */
    public boolean isCatQEmpty(){
        return catQ.isEmpty();
    }

    /**
     * dogQ 队列判空
     * @return
     */
    public boolean isDogQEmpty(){
        return dogQ.isEmpty();
    }

    /**
     * 宠物队列判空
     * @return
     */
    public boolean isQEmpty(){
        return isCatQEmpty() && isDogQEmpty();
    }
}