用Java中的泛型实现队列

尝试创建一个不可变队列并使用泛型对其执行标准队列操作。问题是我对泛型不太了解：（请注意代码的流程和结构

到目前为止我有

import java.lang.*;
import.java.util.*;
import java.util.NoSuchElementException;

public class ImmutableQueue<E>
{
  private final List<E> elmnts;

   public ImmutableQueue(List<E> elmnts) 
    {
     this.elmnts = elmnts;
     return elmnts.newInstance(); 
    }

  public ImmutableQueue() 
  {
    elmnts = new LinkedList<E>();
  }

 public ImmutableQueue<E> enqueue(E e)
 {
    if(e.equals("null"))
      throws IllegalArgumentException;

    List<E> copy = new LinkedList<E>(elmnts);
    copy.add(elmnts);
    copy.addlast(e);
    Iterator iterator = copy.iterator();
    while(iterator.hasNext())
     {
       Object prnt = itr.next();
       System.out.println(prnt+" ");
     }
   }

  public ImmutableQueue<E> dequeue()
  {
     if (elmnts.size() == 0) 
     {
      throw new NoSuchElementException();
     }

    List<E> copy = new LinkedList<E>(elmnts);
    copy.add(elmnts);
    copy.remove(0);

    Iterator iterator = copy.iterator();
     while(iterator.hasNext())
      {
       Object prnt = itr.next();
       System.out.println(prnt+" ");
      }
  } 

  public E peek()
  {
    String fsel=elmnts.get(0);
    System.out.println("First Element in the Queue is "+fsel);
    return null;
   }

  public int size()
  {
    int size=0;
    Iterator iterator = elmnts.iterator();
     while(iterator.hasNext())
     {
      size++; 
     }
    return size;
  }


     public static void main(String [] arg)
     {
        int a;
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in)) ;

        ImmutableQueue<E> imqu=new LinkedList<E>();

        System.out.println("Create Queue/Add Elements to Queue ? ('N' or 'n' to stop)");
       <E> e=br.readLine();

       while(e!='n' || e!='N')
       {  
        imqu.insert(e);
       }

      System.out.println(":: Queue Operations ::");
      System.out.println("\n\n\n21.Enqueue\n2.Dequeue\n3.Peek\n4.size");

      a=Integer.parseInt(br.readLine());
      System.out.println("Choice"+a); 

    switch(a)
    {
     case 1: System.out.println("Element to be Enqueued : ");
             <E> el=br.readLine();
             imqu.enqueue(E el);
             break;

     case 2: imqu.dequeue();
             break;

     case 3: imqu.peek();
             break;

     case 4: int sz=imqu.size();
             System.out.println("Size of the queue is"+sz);
             break;

     default: System.out.println("Bad Choice");

    }
 }
}

import java.lang.*；
import.java.util.*；
导入java.util.NoSuchElementException；
公共类不可变队列
{
非公开最终名单；
公共不可变队列（列表）
{
this.elmnts=elmnts；
返回elmnts.newInstance（）；
}
公共不可变队列（）
{
elmnts=新链接列表（）；
}
公共不可变队列排队（E）
{
如果（e.equals（“null”））
抛出IllegalArgumentException；
列表副本=新链接列表（elmnts）；
副本。添加（elmnts）；
副本。最后添加（e）；
迭代器迭代器=copy.Iterator（）；
while（iterator.hasNext（））
{
对象prnt=itr.next（）；
System.out.println（prnt+“”）；
}
}
公共不可变队列出列（）
{
如果（elmnts.size（）==0）
{
抛出新的NoTouchElementException（）；
}
列表副本=新链接列表（elmnts）；
副本。添加（elmnts）；
复制。删除（0）；
迭代器迭代器=copy.Iterator（）；
while（iterator.hasNext（））
{
对象prnt=itr.next（）；
System.out.println（prnt+“”）；
}
} 
公共E peek（）
{
字符串fsel=elmnts.get（0）；
System.out.println（“队列中的第一个元素是”+fsel）；
返回null；
}
公共整数大小（）
{
int size=0；
迭代器迭代器=elmnts.Iterator（）；
while（iterator.hasNext（））
{
大小++；
}
返回大小；
}
公共静态void main（字符串[]arg）
{
INTA；
BufferedReader br=新的BufferedReader（新的InputStreamReader（System.in））；
ImmutableQueue imqu=new LinkedList（）；
System.out.println（“创建队列/将元素添加到队列？（'N'或'N'停止）”）；
e=br.readLine（）；
而（e！='n'| e！='n'）
{  
插入（e）；
}
System.out.println（“：：队列操作：”）；
System.out.println（“\n\n\n21.Enqueue\n2.Dequeue\n3.Peek\n4.size”）；
a=Integer.parseInt（br.readLine（））；
System.out.println（“选择”+a）；
开关（a）
{
案例1:System.out.println（“要排队的元素：”）；
el=br.readLine（）；
排队（E-el）；
打破
案例2:imqu.dequeue（）；
打破
案例3:imqu.peek（）；
打破
案例4:intsz=imqu.size（）；
System.out.println（“队列的大小为”+sz）；
打破
默认值：System.out.println（“错误选择”）；
}
}
}

---

谢谢

看看这个在Java中使用泛型的队列实现示例。您可以在这里阅读Java泛型

我对您发布的代码做了一些更改。这就是不可变队列的外观。不可变对象不会对其做任何更改，而是会获取对象的副本，对其进行操作并返回java中的同一个.String类就是这样一个例子

import java.util.LinkedList;
import java.util.List;

public class ImmutableQueue<T> {

    private List<T> immuatableQ = null;

    public ImmutableQueue() {
        this.immuatableQ = new LinkedList<T>();
    }

    public ImmutableQueue(List<T> immutableQ) {
        this();
        if (immutableQ != null) {
            this.immuatableQ.addAll(immutableQ);
        }
    }

    public ImmutableQueue<T> enqueue(T newItem) {
        List<T> copyQ = new LinkedList<T>(this.immuatableQ);
        copyQ.add(newItem);

        return new ImmutableQueue<T>(copyQ);
    }

    public ImmutableQueue<T> dequeue() {
        List<T> copyQ = new LinkedList<T>(this.immuatableQ);
        copyQ.remove(0);

        return new ImmutableQueue<T>(copyQ);
    }

    public T peek() {
        return this.immuatableQ.get(0);
    }

    public int size() {
        return this.immuatableQ.size();
    }

    public boolean isEmpty() {
        return this.immuatableQ.size() == 0;
    }

}

import java.util.LinkedList；
导入java.util.List；
公共类不可变队列{
私有列表immuatableQ=null；
公共不可变队列（）{
this.immuatableQ=新的LinkedList（）；
}
公共不可变队列（列表不可变Q）{
这个（）；
if（immutableQ！=null）{
this.immuatableQ.addAll（immutableQ）；
}
}
公共不可变队列排队（T newItem）{
List copyQ=newlinkedlist（this.immuatableQ）；
copyQ.add（newItem）；
返回新的不可变队列（copyQ）；
}
公共不可变队列出列（）{
List copyQ=newlinkedlist（this.immuatableQ）；
copyQ.remove（0）；
返回新的不可变队列（copyQ）；
}
公共T peek（）{
返回此.immuatableQ.get（0）；
}
公共整数大小（）{
返回此.immuatableQ.size（）；
}
公共布尔值为空（）{
返回此.immuatableQ.size（）==0；
}
}

您可以添加更多关于所需内容的信息吗：代码审查？错误跟踪？

返回

在ctor中？？？@smagnan错误跟踪，我不知道如何返回和发送参数generics@Fildor对不起，我不太明白你的意思，“ctor”？不清楚你需要什么。看看代码，有两件事-1）构造函数中有一个return语句，这不是必需的2）而enqueue（）必须获取对象的副本，向其中添加新元素并返回队列的副本（实际上return语句缺失）。3） 同样，对于出列，您必须在删除第一个条目后返回队列的副本。4） 对于大小，您不需要迭代列表，只需list.size即可