天方夜谈_数据结构

package printQueue;

public class fileJob {
     String file;
     int id;
     String owner;
    
     fileJob(String owner,int id,String file){
         this.file=file;
         this.owner=owner;
         this.id=id;
     }
     public String toString(){
         return new String(owner+"  "+id+"  "+file);
     }
     public boolean equals(Object other){
         if(other!=null&&other instanceof fileJob){
             fileJob another=(fileJob)other;
             return id==another.id;
         }
     return false;
     }
}
     //将打印的文件做成一个类，然后用这个类的实例化对象进行操作

package printQueue;

/*
这几个类继承fileJob类，主要是重写了比较方法，按照不用的比较参数，进行匹配
*/

public class ownerJob extends fileJob {

    ownerJob(String owner, int id, String file) {
        super(owner, id, file);
    }
    public boolean equals(Object other){
        if(other!=null&&other instanceof fileJob){
            fileJob another=(fileJob)other;
            return (owner.equals(another.owner));
        }
        return false;
    }
}
class idowner extends fileJob{

    idowner(String owner, int id, String file) {
        super(owner, id, file);
    }
    public boolean equals(Object other){
        if(other!=null&&other instanceof fileJob){
            fileJob another=(fileJob)other;
            return (id==another.id)&&(owner.equals(another.owner));
        }
        return false;
    }
}

package printQueue;

import java.util.*;
import java.io.*;
import structrues.linear.Queue;  //导入后面建立的类Queue类

public class printQueue{

   Queue<fileJob> printQ;
    public printQueue(){
        printQ=new Queue<fileJob>();
    }                                                     //实例化对象
 
    public void lqr(String owner,int id,String file){
        printQ.enqueue(new fileJob(owner,id,file));
    } 
                                                          //添加入队列
    public void lpq(){
        fileJob job=printQ.first();
        while(job!=null){
            System.out.println(job);
            job=printQ.next();
        }
    }                                                //遍历输入队列中所有的项

   //下面几个就是对队列进行出队列和删除队列中的项的操作

    public void lprm(String owner,int idjob){
        if(printQ.isEmpty()){
            throw new NoSuchElementException();
        }
        //删除所有与id相同的项
        printQ.remove(new idowner(owner,idjob,null));
    }
    public void lprm(String owner){
        if(printQ.isEmpty()){
            throw new NoSuchElementException();
        }
        fileJob job = printQ.first();
        if(owner.equals(job.owner)){
            printQ.dequeue();
        }
        else{
            throw new NoSuchElementException();
        }
    }
    public void lprmAll(String owner){
        if(printQ.isEmpty()){
            throw new NoSuchElementException();
        }
        printQ.removeAll(new ownerJob(owner,0,null));
    }
}

package structrues.linear;

import java.util.Collection;
import java.util.LinkedList;
import java.util.NoSuchElementException;

import printQueue.fileJob;

/*类Queue的实现，主要是用了一个LinkedList类，ListedList类的具体实现设计到底层的算法
*/

public class Queue<T> {
     LinkedList<T> list;
     int cursor;
     
    public Queue(){
        list=new LinkedList<T>();
        cursor=-1;
    }
    public void enqueue(T item){
        list.add(item);
    }  //把指定项添加到这个队列的队尾
    public T dequeue(){
        if(list.isEmpty()){
            throw new NoSuchElementException();
        }
        return list.remove(0);
        
    }     /*删除并返回这个队列的对头的项，如果队列为空的话，那就抛出NoSuchElementException */
   public int size(){
        return list.size();
    }     //返回这个队列的项数
    public boolean isEmpty(){
        return list.isEmpty();
    }    //判断这个队列是否为空队列
    public int pisitionOf(T item){
        return list.indexOf(item);
    } //返回指定项在队列中的位置，若不存在则返回null
    public void clear(){
        list.clear();
    }   //删除这个队列的所有项，清空项
    public void remove(T item){
        list.remove(item);
    } //移除项中的item指定项
    public void removeAll(T item){
        list.removeAll((Collection<?>) item);
    }  /*移除队列中所有的指定项，如果不存在，则抛出NoSucnElementException*/
    public T first(){
      if(list.size() == 0){return null;}
      cursor = 0;
      return list.get(cursor);
    }  //返回队列的第一项，即队头。空队列则返回null
    public T next(){
        if(list.size() == 0 || cursor == (list.size()-1)){
            return null;
        }
        cursor++;
        return list.get(cursor);
    } //返回队列的下一项，到达队尾则返回null
}

package printQueue;
public class mainText {

    public static void main(String[] args) {
       printQueue pq=new printQueue();
       pq.lqr("小二",001,"第一个文件");
       pq.lqr("张三",002,"第二个文件");
       pq.lqr("李四",003,"第三个文件");
       pq.lqr("王二麻子",004,"第四个文件");
       pq.lqr("老王",005,"第五个文件");
       System.out.println("运行出来的结果还是蛮不错的嘛");
       System.out.println("需要打印的文件已经按照好顺序准备打印");
       System.out.println();
       pq.lpq();  
    }
}