Java 如何将元素集合添加到我的数组中？

我有一种方法可以将泛型元素集合添加到数组中，但不知道如何实现。我已将我遇到问题的代码行符号化为

COLLECTION

。我不知道写什么来代替这个。我的阵列是一个环形阵列

import java.util.Collection;
import java.util.Iterator;

public class CircularArrayRing<E> implements Ring<E> {

    public E[] elements; //array of E

    private int capacity;
    private int writePos  = 0;
    private int available = 0;

    public CircularArrayRing(int size) {   //circular array constructor

        capacity = size;

    }


    public boolean add(E e) {

        if(available < capacity){ 
            if(writePos >= capacity){
                writePos = 0;
            }
            elements[writePos] = e;     //add element e
            writePos++;
            available--;
            return true;
        }

        return false;

    }

    public boolean addAll(Collection<? extends E> c) {

        if(available < capacity){
            if(writePos >= capacity){
                writePos = 0;
            }
            elements[writePos] = COLLECTION;    //how do add a collection of elements?
            writePos++;
            available++;
            return true;
        }

        return false;
    }
}

import java.util.Collection；
导入java.util.Iterator；
公共类循环rayring实现环{
公共E[]元素；//E的数组
私人int能力；
私有int writePos=0；
可用的私有int=0；
公共循环数组（int size）{//循环数组构造函数
容量=大小；
}
公共布尔加法（E）{
如果（可用<容量）{
if（writePos>=容量）{
writePos=0；
}
元素[writePos]=e；//添加元素e
writePos++；
可用--；
返回true；
}
返回false；
}
public boolean addAll（Collection逐个迭代和触发
add（）
怎么样

public boolean addAll(Collection<? extends E> c){
  for(E e : c){
    add(e);
  }
}

public boolean addAll（Collection逐个迭代和触发
add（）
怎么样

public boolean addAll(Collection<? extends E> c){
  for(E e : c){
    add(e);
  }
}

publicbooleanaddall（Collection函数方式）

c.forEach(this::add);

功能方式

c.forEach(this::add);

您可以在这里找到一些想法：


publicstaticset新闻集（最终T…元素）{
返回新的HashSet（Arrays.asList（elements））；
}
公共静态列表newList（最终T…元素）{
返回新的ArrayList（Arrays.asList（elements））；
}
您可以在这里找到一些想法：


publicstaticset新闻集（最终T…元素）{
返回新的HashSet（Arrays.asList（elements））；
}
公共静态列表newList（最终T…元素）{
返回新的ArrayList（Arrays.asList（elements））；
}
以下是一些示例：

public void testCollectionAdd() {
    if (!isAddSupported()) return;

    Object[] elements = getFullElements();
    for (int i = 0; i < elements.length; i++) {
        resetEmpty();
        boolean r = collection.add(elements[i]);
        confirmed.add(elements[i]);
        verify();
        assertTrue("Empty collection changed after add", r);
        assertTrue("Collection size is 1 after first add",
                   collection.size() == 1);
    }

    resetEmpty();
    int size = 0;
    for (int i = 0; i < elements.length; i++) {
        boolean r = collection.add(elements[i]);
        confirmed.add(elements[i]);
        verify();
        if (r) size++;
        assertEquals("Collection size should grow after add",
                     size, collection.size());
        assertTrue("Collection should contain added element",
                   collection.contains(elements[i]));
    }
}

public void testCollectionAdd（）{
如果（！isAddSupported（））返回；
对象[]元素=getFullElements（）；
for（int i=0；i

完整代码如下：

以下是一些示例：

public void testCollectionAdd() {
    if (!isAddSupported()) return;

    Object[] elements = getFullElements();
    for (int i = 0; i < elements.length; i++) {
        resetEmpty();
        boolean r = collection.add(elements[i]);
        confirmed.add(elements[i]);
        verify();
        assertTrue("Empty collection changed after add", r);
        assertTrue("Collection size is 1 after first add",
                   collection.size() == 1);
    }

    resetEmpty();
    int size = 0;
    for (int i = 0; i < elements.length; i++) {
        boolean r = collection.add(elements[i]);
        confirmed.add(elements[i]);
        verify();
        if (r) size++;
        assertEquals("Collection size should grow after add",
                     size, collection.size());
        assertTrue("Collection should contain added element",
                   collection.contains(elements[i]));
    }
}

public void testCollectionAdd（）{
如果（！isAddSupported（））返回；
对象[]元素=getFullElements（）；
for（int i=0；i

完整代码如下：

迭代集合，增加每个元素的写入位置，并将元素设置在该位置。它基本上与（E:c）{add（E）；}
-的
相同，我可能会这样实现它。只要跟踪返回值，如果得到
false
，就采取行动，或者最好检查
available>=c.size（）
执行循环之前。旁注：我猜
可用++；
不是您想要的
addAll（）中的内容
。附加说明：
available
是什么意思？我假设您的意思是将
available
初始化为
capacity
的值，然后检查
available>0
。迭代集合，增加每个元素的写入位置，并将元素设置在该位置。这是基本的与（E:c）{add（E）；}
的
一样，我可能会这样实现它。只要跟踪返回值，并在得到
false
时采取行动，或者最好在执行循环之前检查
available>=c.size（）
。旁注：我猜
available++；
不是
addAll（）中需要的内容
。附加说明：
可用
是什么意思？我想您的意思是将
可用
初始化为
容量
的值，然后检查
可用>0
。