每日一题 为了工作 2020 0306 第四题

/**
* 题目： 猫狗队列
* 如题可知 宠物、狗、猫的类已知，试实现一种狗猫队列的结构
* 要求：
* 1.用户可以调用add方法将cat类或dog类的实例放入队列。
* 2.用户可以调用pollAll方法，将队列中的所有实例按照进队列的先后顺序依次弹出。
* 3.用户可以调用pollDog方法，将队列中的dog类的实例按照进队列的先后顺序依次弹出。
* 4.用户可以调用pollCat方法，将队列中的cat类的实例按照进队列的先后顺序依次弹出。
* 5.用户可以调用isEmpty方法，检查队列中是否还有dog或cat的实例。
* 6.用户可以调用isDogEmpty方法，检查队列中是否还有dog类的实例。
* 7.用户可以调用isCatEmpty方法，检查队列中是否还有cat类的实例。
* 分析：
* 本题目实现将不同的实例盖上时间戳的方法，但是又不可以改变用户本身的类，所以定义一个新的类，
* 在构造PetEnterQueue类的时候，pet是用户原有的实例，count就是这个实例的时间戳。
* 我们所实现的队里其实就是PetEnterQueue的实例。大体来说，首先有一个不断累加的数据项，用
* 来表示实例进队列的时间；同时有两个队列，一个只放dog类的实例的队列dogQueue，一个只放cat类的实
* 例的队列catQueue。
* 再加入实例时候，如果实例是dog就盖上时间戳，生成对于的PetEnterQueue类的实例，然后放入
* dogQueue中。cat亦然。
* 只想弹出dog类的实例，只需要在dogQueue中不断弹出即可。cat亦然。
* 若按照实际顺序弹出实例时，因为dogQueue的队列头表示所有dog实例中最早进入队列的实例，catQueue
* 队列的队列头表示最早进入的cat实例，因此，只需要比较这两个队列头的时间戳，谁更早就弹出谁。
*
* @author 雪瞳
*
*/

*代码

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");
    }
}

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

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

public class DogCatQueue {
    private Queue<PetEnterQueue> dogQueue;
    private Queue<PetEnterQueue> catQueue;
    private long count;
    //实例化猫狗队列对象
    public DogCatQueue() {
        this.dogQueue = new LinkedList<PetEnterQueue>();
        this.catQueue = new LinkedList<PetEnterQueue>();
        this.count = 0;
    }
    //add方法
    public void add(Pet pet) {
        //由于cat、dog都是继承于Pet类，根据向上转型原则，都属于Pet类
        //PetEnterQueue实例作为一个公共的存储对象，根据宠物类别不同存入不同的队列中
        if(pet.getPetType().equals("dog")) {
            //dogQueue队列所存储的是PetEnterQueue的实例 ，count用作计数比较，使用后自增。
            this.dogQueue.add(new PetEnterQueue(pet, this.count++));
            System.out.println("add dog is ok!");
        }else if(pet.getPetType().equals("cat")) {
            this.catQueue.add(new PetEnterQueue(pet, this.count++));
            System.out.println("add cat is ok!");
        }else {
            throw new RuntimeException("error!this pet is not cat or dog!!!");
        }
    }
    //pollAll方法
    public Pet pollAll() {
        if(!dogQueue.isEmpty() && !catQueue.isEmpty()) {
            //都不为空 比较 顶部元素的count时间戳的值 谁小弹出谁
            //Queue.peek()方法可以返回队列的头部元素，也就是相对应的PetEnterQueue实例，在调用该类的getPetCount方法即可获取时间戳
            //Queue.poll()方法可以弹出队列顶部元素
            if(dogQueue.peek().getPetCount()<catQueue.peek().getPetCount()) {
                Pet tip= this.dogQueue.poll().getPetType();
                System.out.println("poll "+tip.getPetType()+"is ok!");
                return tip;
            }else {
                Pet tip =this.catQueue.poll().getPetType();
                System.out.println("poll "+tip.getPetType()+"is ok!");
                return tip;
            }
        }else if(!dogQueue.isEmpty()) {
            //狗队列不为空 猫队列为空
            Pet tip= this.dogQueue.poll().getPetType();
            System.out.println("poll "+tip.getPetType()+"is ok!");
            return tip;
        }else if(!catQueue.isEmpty()){
            Pet tip =this.catQueue.poll().getPetType();
            System.out.println("poll "+tip.getPetType()+"is ok!");
            return tip;
        }else {
            throw new RuntimeException("error!there is no elements!!!");
        }
    }
    public boolean isDogEmpty() {
        if(this.dogQueue.isEmpty()) {
            return true;
        }else {
            return false;
        }
    }
    public boolean isCatEmpty() {
        return this.catQueue.isEmpty();
    }
    public boolean isEmpty() {
        if(this.dogQueue.isEmpty() && this.catQueue.isEmpty()) {
            return true;
        }else {
            return false;
        }
    }
    public Dog pollDog() {
        if(!this.isDogEmpty()) {
            //如果还有元素
            //返回的是String类型 必须强制转型Dog
            return (Dog) this.dogQueue.poll().getPetType();
        }else {
            throw new RuntimeException("error!the dogQueue is empty!!!");
        }
    }
    public Cat pollcat() {
        if(!this.isCatEmpty()) {
            return (Cat) this.catQueue.poll().getPetType();
        }else {
            throw new RuntimeException("error!the catQueue is empty!!!");
        }
    }
}

import java.util.Random;

public class TestDogAndCatQueue {
    public static void main(String[] args) {
        //实例化对象
        DogCatQueue test = new DogCatQueue();
        Dog dog = new Dog();
        Cat cat = new Cat();
        Pet pet[] = new Pet[] {dog,cat};
        Random rand = new Random();
        int tip = 0;
        //获取十组测试对象
        for(int i=0;i<10;i++) {
            test.add(pet[rand.nextInt(2)]);
        }
        System.out.println("*********add is ok!*********");
        for(int i=0;i<10;i++) {
            test.pollAll();
        }
        System.out.println("*********poll is ok!*********");
    }
}