猫狗队列

题目

宠物、狗、猫类如下

package com.pat;

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

• 用户可以调用add() ，cat类或dog类的实例放入队列中
• 用户可以调用pollAll()，将队列中所有实例按照队列先后顺序依次弹出
• 用户可以调用pollDog()、pollCat()，将队列中dog类、cat类的实例按照进队列的先后顺序依次弹出
• 用户可以调用isEmpty()，检查队列中是否还有dog、cat的实例
• 用户可以调用isDogEmpty()、isCatEmpty()，分别检查队列中是否还有dog、cat的实例

难度 ♥

思路

1. 用户可以调用add() ，cat类或dog类的实例放入队列中

add() 也需要装载一个 Pet 的实例（多态），如何区分继承Pet类的 cat 和 dog 对象

 public Cat(){
    super("cat");
}

由于Cat 和 Dog 的构造方法有 super("xxx") 这下可以用 equals 比较字符串区分不同的 cat 和 dog 对象，然后将符合条件的对象加入进 Cat 或 Dog 的队列中。

//最好避免魔法值，此中仅为示例
boolean bool = pet.getPetType().equal("cat");
if(bool){
 add(pet);
}

2. 用户可以调用pollAll()，将队列中所有实例按照队列先后顺序依次弹出

按照依次按顺序弹出，根据类别的队列中的对象总数或队列的大小，来决定先那个队列使用 poll() 将所有对象出列。比如 Cat 队列的对象少于 Dog 队列，就将 Cat 队列先执行 poll() 。这里将 Cat 队列命名为 catQ，Dog 队列则为 dogQ

if(catQ.size() < dogQ.size()){
	 this.catQ.poll();
}else{
this.dogQ.poll();
}

当然，在此之前还需要做一个非空的判断

   if (this.catQ.isEmpty() && this.dogQ.isEmpty()) {
       throw new RuntimeException("empty");
 }

但其实只要创建一个由猫和狗组合成的共同的类就好了，实现的方法写在其中也OK

实现

package com.pet.dc.queue;

import com.pet.Pet;
import java.util.LinkedList;
import java.util.Queue;

/**
 * @author lorem
 */
public class CatDogQueue {
    private Queue<Pet> catQ;
    private Queue<Pet> dogQ;

    String cat = "cat";
    String dog = "dog";

    public CatDogQueue() {
    // linkedList 本质上和queue 是一样的，先进先出
        this.catQ = new LinkedList<Pet>();
        this.dogQ = new LinkedList<Pet>();
    }

    public void add(Pet pet) {
        if (pet.getPetType().equals(cat)) {
            this.catQ.add(pet);
        }else if(pet.getPetType().equals(dog)) {
            this.dogQ.add(pet);
        } else {
            throw new RuntimeException("err,not cat not dog");
        }
    }

    public void pollAll() {
        if (this.catQ.isEmpty() && this.dogQ.isEmpty()) {
            throw new RuntimeException("empty");
        }
        if (this.catQ.size() > this.dogQ.size()) {
            this.dogQ.poll();
        } else {
            this.catQ.poll();
        }
    }

    public void pollDog() {
        if (!this.dogQ.isEmpty()) {
            this.dogQ.poll();
        } else {
            throw new RuntimeException("dog is empty");
        }
    }

    public void pollCat() {
        if (!this.catQ.isEmpty()) {
            this.catQ.poll();
        } else {
            throw new RuntimeException("cat is empty");
        }
    }

    public boolean isEmpty() {
        if (!this.dogQ.isEmpty() && !this.catQ.isEmpty()) {
            return false;
        }
        return true;
    }

    public boolean isDogEmpty() {
        return this.dogQ.isEmpty();
    }

    public boolean isCatEmpty() {
        return this.catQ.isEmpty();
//       if (this.catQ.isEmpty()){
//           return true;
//       }else{
//           return false;
//       }
    }
}