Java 数组列表

我有两个数组列表

    ArrayList<File> filesImage= new ArrayList<File>();
    ArrayList<File> filesBox= new ArrayList<File>();

---

考虑到您希望合并的两个数组长度相等，我个人会这样做

List<File[]> combinedFiles= new ArrayList<File[]>();

for(int i = 0; i < filesBox.size(); i++){
    combinedFiles.add(new File[] {filesImage.get(i), filesBox.get(i)});
}

List combinedFiles=new ArrayList（）；
对于（int i=0；i

---

抱歉，如果我的方法不正确，我已经有一段时间没有用java编程了。

通常我不会回答OP没有显示他们尝试过什么的问题，但因为我看到大量错误的答案和解释

List<File> filesImage= new ArrayList<File>();
List<File> filesBox= new ArrayList<File>();
List<File[]> combinedFiles=new ArrayList<File[]>();
for (int i = 0; i < filesImage.size(); ++i) {
    File[] temp = new File[2];
    temp[0] = filesImage.get(i);
    temp[1] = filesBox.get(i);
    combinedFiles.add(temp);
}

List filesImage=new ArrayList（）；
List filesBox=new ArrayList（）；
List combinedFiles=new ArrayList（）；
对于（int i=0；i

---

顺便说一句，在函数式编程中，类似的东西被称为“压缩”。我建议使用Java 8 lambdas解决方案，但Java SE中似乎没有zip函数，上面的内容非常简单。

首先，我创建一个保存文件引用的类，例如：

class FileElement {
  File image;
  File box;
}

然后我会创建一个列表，而不是数组：

List<FileElement> combinedFiles = ...;

列出组合文件=。。。；

然后我会同时迭代两个列表：

Iterator<File> imgItr = filesImages.iterator();
Iterator<File> boxItr = filesBox.iterator();

//This assumes it's ok if both lists have different sizes. 
//If it isn't you could try && instead, i.e. stop once you'd miss an image or a box
while( imgItr.hasNext() || boxItr.hasNext() ) {
   FileElement e = ...;

   if( imgItr.hasNext() ) { 
     e.image = imgItr.next();
   }

   if( boxItr.hasNext() ) { 
     e.box= boxItr.next();
   }

   combinedFiles.add( e );
}

Iterator imgItr=filesmimages.Iterator（）；
迭代器boxItr=filesBox.Iterator（）；
//这假设两个列表的大小不同就可以了。
//如果不是，您可以尝试&&相反，即，一旦您错过图像或方框，请停止
while（imgItr.hasNext（）| | boxItr.hasNext（））{
FileElement e=。。。；
if（imgItr.hasNext（））{
e、 image=imgItr.next（）；
}
if（boxItr.hasNext（））{
e、 box=boxItr.next（）；
}
添加（e）；
}

假设两个列表长度相等，下面是一个使用Java8 streams和zip（）的解决方案

导入java.util.array；
导入java.util.Iterator；
导入java.util.List；
导入java.util.function.BiFunction；
导入java.util.stream.collector；
导入java.util.stream.stream；
导入java.util.stream.StreamSupport；
公开课演示{
公共静态void main（字符串[]args）{
List filesImage=Arrays.asList（“a”、“b”、“c”）；
List filesBox=Arrays.asList（“1”、“2”、“3”）；
List result=zip（fileimage.stream（），filebox.stream（），（a，b）->新字符串[]{a，b}）.collect（Collectors.toList（））；
for（字符串[]e:result）{
System.out.println（Arrays.asList（e））；
}
}
public static.Zip是函数世界中以这种方式组合两个列表的模式的名称。还请注意，虽然演示使用字符串而不是文件，但概念仍然完全相同。
应该与此伪代码类似

List<File[]> merge = new ArrayList<>();

for(int i=0;i<filesImage.legth&&i<filesBox.length;i++{
    merge.add(new File[]{i<filesImage.legth?filesImage[i]:null,i<filesBox.legth?filesBox[i]});
}

List merge=new ArrayList（）；
对于（inti=0；i您可以使用函数toArray of List来生成数组

ArrayList<File> filesImage= new ArrayList<File>();
    ArrayList<File> filesBox= new ArrayList<File>();
 ArrayList<File[]> combinedFiles=new ArrayList<File[]>();
//add content to 2 lists here
File[] arrayFiles;

//add array image
arrayFiles = new File[filesImage.size()];
arrayFiles = filesImage.toArray(arrayFiles);
combinedFiles.add(arrayFiles);
//add array box
arrayFiles = new File[filesBox.size()];
arrayFiles = filesBox.toArray(arrayFiles);
combinedFiles.add(arrayFiles);

System.out.println(combinedFiles);

ArrayList filesImage=新建ArrayList（）；
ArrayList fileBox=新的ArrayList（）；
ArrayList combinedFiles=新的ArrayList（）；
//在此处向2个列表添加内容
文件[]数组文件；
//添加阵列图像
arrayFiles=新文件[filesImage.size（）]；
arrayFiles=filesImage.toArray（arrayFiles）；
添加（数组文件）；
//添加数组框
arrayFiles=新文件[filesBox.size（）]；
arrayFiles=filesBox.toArray（arrayFiles）；
添加（数组文件）；
System.out.println（组合文件）；
@ΦXocę웃Пepeúpaツ 不，那个加法是线性的。不是作为一个单独的数组。到目前为止你们都试过什么？@ΦXocę웃Пepeúpaツ addAll会将一个集合中的所有条目添加到另一个集合中，而不是“zip”它们成对地排列在数组中。如何同时迭代列表，并为每次迭代构建和添加元素数组？或者更好，为什么不构建一个包含两个文件引用的小对象，以使其更不容易出错并更易于理解？作为旁白，我可能会使用
Map
，而不是更准确地按数据结构。但基本解决方案在两种情况下都是一样的：并行迭代两个列表，并在每一步中从每个列表中选择一个元素。@biziclop我尝试了映射它的工作方式，但不是我想要的方式。它给出一个键值对。我想在ArrayList数组中存储两个文件的路径。我认为唯一缺少的是检查两个ArrayList的大小是否相同。拥有一个通用的zip操作当然很好（我想知道为什么JavaSE的API中没有它）但我认为这对于OP的用例来说可能有点过火了，而且考虑到他们提出的问题，这可能超出了他们的理解力。@G_H这对于记录其他遇到这个问题的人来说是非常有用的。我的第一个想法是“哦，一个拉链”我有点惊讶Java没有开箱即用。这似乎是一个相当基本的FP操作。如果在类中添加了额外的功能，则将内容封装在类中是很有用的，否则2元素数组似乎很好。除非必要，否则无需发明更多的类。我希望Java有一个Pair类…@G_H有理由这样做没有pair类，一个是在大多数情况下最好为pair中的元素提供名称（例如，他们提到的2d点不仅仅是2个
int
元素，而是提供类似
x
和
y
的名称）。使用特定类有助于使代码更易于阅读，因为如果将来阅读
combinedFiles.get（0）[0]
您将不知道该文件是什么，但如果阅读
combinedFiles.get（0）.image
您知道它是一个图像文件。好的一点是，带数组的ArrayList可能会被传递到其他上下文中，而不是本地使用，或者一开始就不需要。
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.function.BiFunction;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;


public class Demo {

    public static void main( String[] args ) {
        List<String> filesImage = Arrays.asList("a","b","c");
        List<String> filesBox   = Arrays.asList("1","2", "3");

        List<String[]> result = zip(filesImage.stream(), filesBox.stream(), (a,b) -> new String[] {a,b}).collect( Collectors.toList() );

        for ( String[] e : result ) {
            System.out.println( Arrays.asList(e) );
        }
    }

    public static <A, B, C> Stream<C> zip(Stream<A> streamA, Stream<B> streamB, BiFunction<A, B, C> zipper) {
        final Iterator<A> iteratorA = streamA.iterator();
        final Iterator<B> iteratorB = streamB.iterator();
        final Iterator<C> iteratorC = new Iterator<C>() {
            @Override
            public boolean hasNext() {
                return iteratorA.hasNext() && iteratorB.hasNext();
            }

            @Override
            public C next() {
                return zipper.apply(iteratorA.next(), iteratorB.next());
            }
        };
        final boolean parallel = streamA.isParallel() || streamB.isParallel();
        return iteratorToFiniteStream(iteratorC, parallel);
    }

    public static <T> Stream<T> iteratorToFiniteStream( Iterator<T> iterator, boolean parallel) {
        final Iterable<T> iterable = () -> iterator;
        return StreamSupport.stream(iterable.spliterator(), parallel);
    }
}

List<File[]> merge = new ArrayList<>();

for(int i=0;i<filesImage.legth&&i<filesBox.length;i++{
    merge.add(new File[]{i<filesImage.legth?filesImage[i]:null,i<filesBox.legth?filesBox[i]});
}

ArrayList<File> filesImage= new ArrayList<File>();
    ArrayList<File> filesBox= new ArrayList<File>();
 ArrayList<File[]> combinedFiles=new ArrayList<File[]>();
//add content to 2 lists here
File[] arrayFiles;

//add array image
arrayFiles = new File[filesImage.size()];
arrayFiles = filesImage.toArray(arrayFiles);
combinedFiles.add(arrayFiles);
//add array box
arrayFiles = new File[filesBox.size()];
arrayFiles = filesBox.toArray(arrayFiles);
combinedFiles.add(arrayFiles);

System.out.println(combinedFiles);