Question

以下代表通用Queue类的代码。现在，我试图在main中做的，我尝试使用Queue类创建一个Integer数组的数组。但是，由于我没有设法将整数数组中的元素正确添加到队列中，因此我在尝试中失败了。这是代码和一些解释：

主要：

import java.util.Iterator;

public class Main 
    {public static void main(String[] args)
        {Queue <Integer[][]> Q= new Queue<Integer[][]>(); // creating the queue
        Integer []i1={1,2,3};
        Integer []i2={1,2,3};
        Integer [][]i=new Integer[][]{i1,i2}; // creating the array of integer arrays
        Q.add(i);

        for(Iterator<Integer[][]> it=Q.iterator(); it.hasNext();){ System.out.print(it.next()+" "); }
        System.out.println();

        Iterator<Integer[][]> it=Q.iterator();
        it.next();
        it.remove();
        System.out.println(Q);

        }
    }

这是Queue类：

import java.util.*;

public class Queue <T> 
    {LinkedList<T>queue=new LinkedList<T>();
    public void add(T x){ queue.add(x); NOF++; } // the regular add function

    public void add(T[][] x) // the add function in case we get an array of Integer arrays
        { int i=0,j=0,k=0; T [] v; 
        while(x[i][j]!=null) // checking if the are still availabe arrays
            { v=x[i][j]; //1 passing to v an array (or at least what I thought I'd pass)
                                         //but i don't think it works
            while(v[k]!=null)   // while the arrays has elements, add them to the queue
                { queue.add(v); 
                j++;  
                NOF++;
                k++; }
            j++; } }


    public void remove(T x){ queue.remove(); }
    public T peek(T x){ return queue.peek(); }
    public String toString(){ String S=""; for(T x: queue)S=S + x + " "; return S; }
    static int NOF=0;

    public class QueueIterator<T> implements Iterator<T>
        { int index=0;
        public boolean hasNext(){ return index < queue.size(); }
        public T next(){ return (T) queue.get(index++); }
        public void remove(){ if(index>0)queue.remove(index-1); } } 

    public Iterator<T> iterator(){ return new QueueIterator<T>(); }

    }

所以它显然不起作用，但我不明白为什么，在// 1我得到错误：

类型不匹配，无法从T转换为T []

但我不明白为什么，x [i] [j]也应该是T []。

任何想法，同性恋？

Answer 1

您有一个Queue<Integer[][]>，但是您有T[][]的添加内容，即Integer[][][][]。在此处使用泛型时，T为Integer[][]。

如果您想要添加多个单独的元素，那么您将考虑接受T的数组（或varargs），并使T类似Integer[] 1}}：

public void addAll(T... values) {
    //add all from values
}

最后，您应该始终如一地格式化代码，以便更容易阅读。

Answer 2

你的问题很简单（有点令人惊讶的是给出了过于复杂的编码风格！）

您似乎想要创建一个隐式与两个Dim数组T一起工作的队列：

class Queue<T> ...
  public void add(T[][] x)

但是那时你用二维数组再次实例化那个东西：

Queue <Integer[][]> Q = ...

从这个意义上说，你在这里“加倍”了。

您只需将队列用法更改为

即可

Queue <Integer> Q = ...

使事情有效！

但这是错误的解决方案。您会看到：根本不需要这些数组信息。

让你的Queue实现处理T对象。在整个地方使用T [] []不会给你任何值！ Queue类代码中没有任何东西依赖于你期望一个双Dim数组T！

的事实

含义：你会把这些信息放到你的客户端（所以，你会继续说Integer[][]。但那时：那也是错误的：混合数组中有没有点和集合。如果你真的需要两个维度，可以使用List<Integer>或List<List<Integer>>。

编辑：

A）第一个建议......解决你的问题，转入你的Q类，然后删除你在那里的任何[] []。然后你可以按原样保留你的Main类，并且应该编译。

B）但是，你应该考虑改变你的Main类 - 使它使用Lists而不是数组！

Answer 3

为了分开事物，这里有一个编译得很好的版本：我有两个特殊的添加方法，一个是T列表，另一个是T列表。

我通过eclipse格式化程序运行它; - ）

我也删除了NOF计数器，因为我很确定：你可以查询那个内部队列对象！

import java.util.*;

public class Queue<T> {
LinkedList<T> queue = new LinkedList<T>();

public void add(T x) {
    queue.add(x);
} // the regular add function

public void addAll(List<T> xes) {
    queue.addAll(xes);
} // for adding multiple values

public void addAllTimes2(List<List<T>> xesTimes2) {
    for (List<T> xes : xesTimes2) {
        addAll(xes);
    }
} // for adding multiple values

public void remove(T x) {
    queue.remove();
}

public T peek(T x) {
    return queue.peek();
}

public String toString() {
    String S = "";
    for (T x : queue)
        S = S + x + " ";
    return S;
}

public class QueueIterator implements Iterator<T> {
    int index = 0;

    public boolean hasNext() {
        return index < queue.size();
    }

    public T next() {
        return queue.get(index++);
    }

    public void remove() {
        if (index > 0) queue.remove(index - 1);
    }
}

public Iterator<T> iterator() {
    return new QueueIterator();
}

public static void main(String[] args) {
    Queue<Integer> Q = new Queue<>(); // creating the queue

    List<Integer> i1 = Arrays.asList(1, 2, 3);
    List<Integer> i2 = Arrays.asList(1, 2, 3);
    Q.addAll(i1);
    List<List<Integer>> i = Arrays.asList(i1, i2); // creating the array of integer arrays
    Q.addAllTimes2(i);
    for (Iterator<Integer> it = Q.iterator(); it.hasNext();) {
        System.out.print(it.next() + " ");
    }
    System.out.println();

    Iterator<Integer> it = Q.iterator();
    it.next();
    it.remove();
    System.out.println(Q);

}
}

Java：使用泛型类

3 个答案: