数组数组

Question

我有两张排列表

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

我想像这样合并成第三列

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

我该怎么做？产出应如下：

   [[ first object of filesImage, first object of filesBox],[second Object],[]]

Answer 1

考虑到这两个数组的长度是相等的，您希望将它们组合起来，我会亲自这样做。

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

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

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

Answer 2

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

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 );
}

Answer 3

假设这两个列表长度相等，下面是使用Java8 streams和zip()的解决方案。

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);
    }
}

我从Karol here那里借用了zip的实现。Zip是函数世界中以这种方式组合两个列表的模式的名称。还请注意，尽管Demo使用String而不是File，但概念仍然完全相同。