|
给你一个这样的类：
public class DogCatqQueue {
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.用户可以调用pollAll方法，将队列中所有的实例按照队列的先后顺序依次弹出；
3.用户可以调用pollDog方法，将队列中dog类的实例按照队列的先后顺序依次弹出；
4.用户可以调用pollCat方法，将队列中cat类的实例按照队列的先后顺序依次弹出；
5.用户可以调用isEmpty方法，检查队列中是否还有dog和cat的实例；
6.用户可以调用isDogEmpty方法，检查队列中是否还有dog的实例；
7.用户可以调用isCatEmpty方法，检查队列中是否还有cat的实例。
思路：实现一个新的队列，里面包含猫队列与狗队列（可跳过直接看方法2的实现）
当添加宠物为猫时，调用猫队列的添加方法，添加宠物为狗时，同理，检查队列中有无猫//狗时，直接调用相应队列是否为空的方法。这样，1，3，4，6，7都可以实现。
然后对此新的队列进行改进，加一个计数变量，每进入一个宠物记一次数，变量为0即队列已空即可得到5方法。（或者分别查询猫狗队列是否为空也可实现5方法）
方法2的实现：
增加一个count变量，绑定在宠物本身，给宠物一个编号，记录入栈顺序。在add时，增加宠物以及他的编号。在弹出时，可分别弹出猫和狗，对比编号入栈顺序，进行相应的弹出。（类似于c++中的结构体，进队列的是int与pet组成的结构体而非pet本身）
package Queue;
import java.util.LinkedList;
import java.util.Queue;
import Queue.DogCatqQueue.CountPet;
public class DogCatqQueue {
public static class Pet {
private String type;
public Pet(String type) {
this.type = type;
}
public String getPetType() {
return this.type;
}
}
public static class Dog extends Pet {
public Dog() {
super("dog");
}
}
public static class Cat extends Pet {
public Cat() {
super("cat");
}
}
//自定义一个带有编号的宠物类
public static class CountPet {
private Pet pet;
private int count;
CountPet(Pet a, int b) {
this.pet = a;
this.count = b;// 记录是第几个进入猫狗队列的
}
public Pet getPet() {
return this.pet;
}
public int getCount() {
return this.count;
}
}
//猫狗队列
public static class CatDogQueue {
Queue<CountPet> catq;
Queue<CountPet> dogq;// 此队列之进入pet类型为dog，具体对象类型为 CountPet
private int count;// 记录猫狗队列中宠物数量中
CatDogQueue() {
catq = new LinkedList<CountPet>();
dogq = new LinkedList<CountPet>();
count = 0;// count初始化
}
// 进队列的方法
public void add(Pet pet) {
if (pet.getPetType().equals("dog")) {
dogq.add(new CountPet(pet, this.count++));
} else if (pet.getPetType().equals("cat")) {
catq.add(new CountPet(pet, this.count++));
} else
throw new RuntimeException("没有这样的宠物！！！");
}
public Pet pollall() {
if(!dogq.isEmpty()&&!catq.isEmpty()) {
int a=dogq.peek().getCount();
int b=catq.peek().getCount();
return a<b?dogq.poll().getPet():catq.poll().getPet();
}
else if(!dogq.isEmpty()) {
return dogq.poll().getPet();
}
else if(!catq.isEmpty()) {
return catq.poll().getPet();
}
else throw new RuntimeException("队列已空");
}
public Dog pollDog() {
if(!dogq.isEmpty())
{return (Dog) dogq.poll().getPet();}
else throw new RuntimeException("狗队列已空");
}
public Cat pollCat() {
if(!catq.isEmpty())
return (Cat) catq.poll().getPet();
else throw new RuntimeException("猫队列已空");
}
public boolean isEmpty() {
return (dogq.isEmpty() && catq.isEmpty());
}
public boolean isDogEmpty() {
return dogq.isEmpty();
}
public boolean isCatEmpty() {
return catq.isEmpty();
}
}
//主函数
public static void main(String []args) {
CatDogQueue test=new CatDogQueue();
Pet dog1=new Dog();
Pet dog2=new Dog();
Pet dog3=new Dog();
Pet cat1=new Cat();
Pet cat2=new Cat();
Pet cat3=new Cat();
test.add(dog1);
test.add(dog2);
test.add(cat1);
test.add(cat2);
test.add(dog3);
test.add(cat3);
/*while (!test.isDogEmpty()) {
System.out.println(test.pollDog().getPetType());
}*/
while (!test.isEmpty()) {
System.out.println(test.pollall().getPetType());
}
}
}
| 
转播
