猫狗队列

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

1. 用户可以调用 add 方法将 cat 或者 dog 放入队列中
2. 用户可以调用 pollAll 方法将队列中的 cat 和 dog 按照进队列的先后顺序依次弹出
3. 用户可以调用 pollDog 方法将队列中的 dog 按照进队列的先后顺序依次弹出
4. 用户可以调用 pollCat 方法将队列中的 cat 按照进队列的先后顺序依次弹出
5. 用户可以调用 isEmpty 方法检查队列中是否还有 dog 或 cat
6. 用户可以调用 isDogEmpty 方法检查队列中是否还有 dog
7. 用户可以调用 isCatEmpty 方法检查队列中是否还有 cat

这道题本身并不是特别难，主要还是输入数据那里的要求有点变态。这里如果用普通的scanner输入数据，无论我怎么优化程序，最终都是超时。看过别人的代码之后，才知道原来还有BufferedReader这个类，然后才成功的通过了测试。

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Queue;
import java.util.LinkedList;
import java.util.Scanner;
class Pet {
    private String type;
    private String number;
    public Pet(String type, String number) {
        this.number = number;
        this.type = type;
    }
    public String getType() {
        return this.type;
    }
    public String getNumber() {
        return this.number;
    }
}
class Dog extends Pet {
    public Dog(String number) {
        super("Dog", number);
    }
}
class Cat extends Pet {
    public Cat(String number) {
        super("Cat", number);
    }
}
class PetEnterQueue {
    private Pet pet;
    private int count;
    public PetEnterQueue(Pet pet, int count) {
        this.pet = pet;
        this.count = count;
    }
    public Pet getPet() {
        return this.pet;
    }
    public int getCount() {
        return this.count;
    }
    public String getType() {
        return this.pet.getType();
    }
}
class DogCatQueue {
    private Queue<PetEnterQueue> dogQueue;
    private Queue<PetEnterQueue> catQueue;
    private int count;
    public DogCatQueue() {
        this.dogQueue = new LinkedList<>();
        this.catQueue = new LinkedList<>();
        this.count = 0;
    }
    public void add(Pet pet) {
        if (pet.getType().equals("cat")) {
            catQueue.add(new PetEnterQueue(pet, this.count++));
        } else if (pet.getType().equals("dog")) {
            dogQueue.add(new PetEnterQueue(pet, this.count++));
        } else {
            // 这里要new一个
            throw new RuntimeException("It's not a cat or dog");
        }
    }
    public void pollAll() {
        while (!catQueue.isEmpty() && !dogQueue.isEmpty()) {
            if (catQueue.peek().getCount() < dogQueue.peek().getCount()) {
                Pet pet = catQueue.poll().getPet();
                System.out.println(pet.getType() + " " + pet.getNumber());
            } else {
                Pet pet = dogQueue.poll().getPet();
                System.out.println(pet.getType() + " " + pet.getNumber());
            }
        }
        while (!catQueue.isEmpty()) {
            Pet pet = this.catQueue.poll().getPet();
            System.out.println(pet.getType() + " " + pet.getNumber());
        }
        while (!dogQueue.isEmpty()) {
            Pet pet = dogQueue.poll().getPet();
            System.out.println(pet.getType() + " " + pet.getNumber());
        }
    }
    public void pollCat() {
        while (!catQueue.isEmpty()) {
            PetEnterQueue poll = this.catQueue.poll();
            System.out.println(poll.getType() + " " + poll.getPet().getNumber());
        }
    }
    public void pollDog() {
        while (!dogQueue.isEmpty()) {
            Pet pet = this.dogQueue.poll().getPet();
            System.out.println(pet.getType() + " " + pet.getNumber());
        }
    }
    public void isDogEmpty() {
        if (this.dogQueue.isEmpty())
            System.out.println("yes");
        else
            System.out.println("no");
    }
    public void isCatEmpty() {
        if (this.catQueue.isEmpty())
            System.out.println("yes");
        else
            System.out.println("no");
    }
    public void isEmpty() {
        if (this.dogQueue.isEmpty() && this.catQueue.isEmpty())
            System.out.println("yes");
        else
            System.out.println("no");
    }
}
public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
        String s = "";
        while ((s = bf.readLine()) != null) {
            int epoch = Integer.valueOf(s);
            DogCatQueue dogCatQ = new DogCatQueue();
            for (int i = 0; i < epoch; i++) {
                String[] commands = bf.readLine().split(" ");
                switch (commands[0]) {
                    case "add":
                        dogCatQ.add(new Pet(commands[1], commands[2]));
                        break;
                    case "pollAll":
                        dogCatQ.pollAll();
                        break;
                    case "pollDog":
                        dogCatQ.pollDog();
                        break;
                    case "pollCat":
                        dogCatQ.pollCat();
                        break;
                    case "isEmpty":
                        dogCatQ.isEmpty();
                        break;
                    case "isDogEmpty":
                        dogCatQ.isDogEmpty();
                        break;
                    case "isCatEmpty":
                        dogCatQ.isCatEmpty();
                        break;
                }
            }
        }
    }
}